From 2887a0f5597b16f4070d9a78b1b3ab849deedd55 Mon Sep 17 00:00:00 2001 From: "V.Shkriabets" Date: Mon, 27 Oct 2025 22:05:10 +0200 Subject: [PATCH 1/2] C++ type use cases will update includes --- .../cpp/CppConstantsBlockGenerator.kt | 9 +++- .../generators/cpp/CppDataClassGenerator.kt | 29 +++++++++-- .../kotlin/generators/cpp/CppEnumGenerator.kt | 5 +- .../generators/cpp/GetArrayDataTypeUseCase.kt | 7 ++- .../generators/cpp/GetTypeNameUseCase.kt | 41 ++++++++++++--- .../cpp/PrepareRightValueUseCase.kt | 18 +++---- .../cpp/GetArrayDataTypeUseCaseTest.kt | 39 ++++++++++---- .../generators/cpp/GetTypeNameUseCaseTest.kt | 52 +++++++++++++++++++ .../cpp/PrepareRightValueUseCaseTest.kt | 52 +++++++++++++------ test/enumGoldErrors.groovy | 5 ++ 10 files changed, 205 insertions(+), 52 deletions(-) create mode 100644 cgen-lib/src/test/java/generators/cpp/GetTypeNameUseCaseTest.kt diff --git a/cgen-lib/src/main/kotlin/generators/cpp/CppConstantsBlockGenerator.kt b/cgen-lib/src/main/kotlin/generators/cpp/CppConstantsBlockGenerator.kt index c42e2f9..9112d71 100644 --- a/cgen-lib/src/main/kotlin/generators/cpp/CppConstantsBlockGenerator.kt +++ b/cgen-lib/src/main/kotlin/generators/cpp/CppConstantsBlockGenerator.kt @@ -10,11 +10,13 @@ import generators.obj.abstractSyntaxTree.addDatatype import generators.obj.abstractSyntaxTree.addKeyword import generators.obj.abstractSyntaxTree.addSub import generators.obj.abstractSyntaxTree.addVarName +import generators.obj.abstractSyntaxTree.findOrCreateSub import generators.obj.abstractSyntaxTree.findOrNull import generators.obj.abstractSyntaxTree.getParentPath import generators.obj.syntaxParseTree.CommentsBlock import generators.obj.syntaxParseTree.FieldNode import generators.obj.syntaxParseTree.FileData +import generators.obj.syntaxParseTree.ImportsBlock import generators.obj.syntaxParseTree.NamespaceBlock import generators.obj.syntaxParseTree.RegionImpl @@ -26,6 +28,7 @@ class CppConstantsBlockGenerator( override fun invoke(blockFiles: List, desc: ConstantsBlock) { val headerFile = blockFiles.find { it is CppHeaderFile } ?: throw java.lang.IllegalStateException("Can't find Header file for C++") + val imports = headerFile.findOrCreateSub(ImportsBlock::class.java) val namespace = headerFile.addSub(NamespaceBlock(desc.getParentPath())) val outBlock = namespace.addSub(RegionImpl(desc.name)) @@ -48,7 +51,11 @@ class CppConstantsBlockGenerator( addDatatype(Types.typeTo(headerFile, it.getType())) addVarName(it.name) addKeyword("=") - val rValue = prepareRightValueUseCase.toRightValue(it.getType(), it.getValue(), headerFile) + val rValue = prepareRightValueUseCase.toRightValue( + type = it.getType(), + value = it.getValue(), + importsBlock = imports + ) addSub(rValue) } ) diff --git a/cgen-lib/src/main/kotlin/generators/cpp/CppDataClassGenerator.kt b/cgen-lib/src/main/kotlin/generators/cpp/CppDataClassGenerator.kt index 4a07e47..3ed1efd 100644 --- a/cgen-lib/src/main/kotlin/generators/cpp/CppDataClassGenerator.kt +++ b/cgen-lib/src/main/kotlin/generators/cpp/CppDataClassGenerator.kt @@ -2,8 +2,23 @@ package generators.cpp import ce.domain.usecase.add.AddRegionDefaultsUseCase import generators.obj.TransformBlockUseCase -import generators.obj.abstractSyntaxTree.* -import generators.obj.syntaxParseTree.* +import generators.obj.abstractSyntaxTree.DataClass +import generators.obj.abstractSyntaxTree.DataField +import generators.obj.abstractSyntaxTree.addCommentLine +import generators.obj.abstractSyntaxTree.addDatatype +import generators.obj.abstractSyntaxTree.addKeyword +import generators.obj.abstractSyntaxTree.addOutBlock +import generators.obj.abstractSyntaxTree.addSub +import generators.obj.abstractSyntaxTree.addVarName +import generators.obj.abstractSyntaxTree.findOrCreateSub +import generators.obj.abstractSyntaxTree.findOrNull +import generators.obj.abstractSyntaxTree.getParentPath +import generators.obj.syntaxParseTree.CommentsBlock +import generators.obj.syntaxParseTree.FieldNode +import generators.obj.syntaxParseTree.FileData +import generators.obj.syntaxParseTree.ImportsBlock +import generators.obj.syntaxParseTree.NamespaceBlock +import generators.obj.syntaxParseTree.RegionImpl class CppDataClassGenerator( private val addBlockDefaultsUseCase: AddRegionDefaultsUseCase, @@ -15,6 +30,7 @@ class CppDataClassGenerator( val header = blockFiles.find { it is CppHeaderFile } ?: throw java.lang.IllegalStateException("Can't find Header file for C++") header.findOrCreateSub(ImportsBlock::class.java) + val imports = header.findOrCreateSub(ImportsBlock::class.java) val namespace = header.addSub(NamespaceBlock(desc.getParentPath())) @@ -30,13 +46,18 @@ class CppDataClassGenerator( desc.subs.forEach { leaf -> if (leaf is DataField) { addSub(FieldNode().apply { - addDatatype(dataTypeToString.typeTo(header, leaf.getType())) + addDatatype( + dataTypeToString.typeTo( + importsBlock = imports, + type = leaf.getType() + ) + ) addVarName(leaf.name) if (leaf.getValue().isDefined()) { addKeyword("=") val rValue = prepareRightValueUseCase.toRightValue( dataField = leaf, - fileData = header + importsBlock = imports ) addSub(rValue) } diff --git a/cgen-lib/src/main/kotlin/generators/cpp/CppEnumGenerator.kt b/cgen-lib/src/main/kotlin/generators/cpp/CppEnumGenerator.kt index 0d8065b..7047a0b 100644 --- a/cgen-lib/src/main/kotlin/generators/cpp/CppEnumGenerator.kt +++ b/cgen-lib/src/main/kotlin/generators/cpp/CppEnumGenerator.kt @@ -12,10 +12,12 @@ import generators.obj.abstractSyntaxTree.addKeyword import generators.obj.abstractSyntaxTree.addOutBlock import generators.obj.abstractSyntaxTree.addSub import generators.obj.abstractSyntaxTree.addVarName +import generators.obj.abstractSyntaxTree.findOrCreateSub import generators.obj.abstractSyntaxTree.findOrNull import generators.obj.abstractSyntaxTree.getParentPath import generators.obj.syntaxParseTree.CommentsBlock import generators.obj.syntaxParseTree.FileData +import generators.obj.syntaxParseTree.ImportsBlock import generators.obj.syntaxParseTree.NamespaceBlock import generators.obj.syntaxParseTree.RegionImpl @@ -27,6 +29,7 @@ class CppEnumGenerator( override fun invoke(files: List, desc: ConstantsEnum) { val headerFile = files.find { it is CppHeaderFile } ?: throw java.lang.IllegalStateException("Can't find Header file for C++") + val imports = headerFile.findOrCreateSub(ImportsBlock::class.java) val namespace = headerFile.addSub(NamespaceBlock(desc.getParentPath())) val region = namespace.addSub(RegionImpl(desc.name)) @@ -49,7 +52,7 @@ class CppEnumGenerator( autoIncrement(it) val rValue = prepareRightValueUseCase.toRightValue( dataField = it, - fileData = headerFile + importsBlock = imports ) addEnumLeaf("").apply { addVarName(it.name) diff --git a/cgen-lib/src/main/kotlin/generators/cpp/GetArrayDataTypeUseCase.kt b/cgen-lib/src/main/kotlin/generators/cpp/GetArrayDataTypeUseCase.kt index ecb9316..d7ef060 100644 --- a/cgen-lib/src/main/kotlin/generators/cpp/GetArrayDataTypeUseCase.kt +++ b/cgen-lib/src/main/kotlin/generators/cpp/GetArrayDataTypeUseCase.kt @@ -1,10 +1,12 @@ package generators.cpp import ce.defs.DataType +import generators.obj.syntaxParseTree.ImportsBlock class GetArrayDataTypeUseCase { - fun getArrayType(type: DataType): String = - when (type) { + fun getArrayType(type: DataType, importsBlock: ImportsBlock): String { + importsBlock.addInclude("") + return when (type) { DataType.int8 -> "std::vector" DataType.uint8 -> "std::vector" DataType.int16 -> "std::vector" @@ -20,4 +22,5 @@ class GetArrayDataTypeUseCase { is DataType.custom -> "std::vector<${type.block.name}>" else -> "ktQQTP_array_$type" } + } } \ No newline at end of file diff --git a/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt b/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt index f4731e1..0f2c4ae 100644 --- a/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt +++ b/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt @@ -1,24 +1,53 @@ package generators.cpp import ce.defs.DataType -import generators.obj.abstractSyntaxTree.findOrCreateSub import generators.obj.abstractSyntaxTree.getParentPath import generators.obj.abstractSyntaxTree.getPath -import generators.obj.syntaxParseTree.FileData import generators.obj.syntaxParseTree.ImportsBlock class GetTypeNameUseCase( private val arrayDataType: GetArrayDataTypeUseCase ) { - fun typeTo(file: FileData, + fun typeTo(importsBlock: ImportsBlock, type: DataType ) : String { when (type) { is DataType.custom -> - file.findOrCreateSub(ImportsBlock::class.java) - .addInclude("${type.block.getParentPath()}.${type.block.name}"); + importsBlock.addInclude("${type.block.getParentPath()}.${type.block.name}"); else -> {} } + when (type) { + DataType.int8, + DataType.int16, + DataType.int32, + DataType.int64, + DataType.uint8, + DataType.uint16, + DataType.uint32, + DataType.uint64, + DataType.int8Nullable, + DataType.int16Nullable, + DataType.int32Nullable, + DataType.int64Nullable, + DataType.uint8Nullable, + DataType.uint16Nullable, + DataType.uint32Nullable, + DataType.uint64Nullable-> { + importsBlock.addInclude("") + } + DataType.string, DataType.stringNullable -> { + importsBlock.addInclude("") + } + is DataType.array -> { + importsBlock.addInclude("") + } + else -> { + + } + } + if (type.canBeNull) { + importsBlock.addInclude("") + } val baseType = when (type) { DataType.VOID -> "void" DataType.int8, DataType.int8Nullable -> "int8_t" @@ -34,7 +63,7 @@ class GetTypeNameUseCase( DataType.bool, DataType.boolNullable -> "bool" DataType.string, DataType.stringNullable -> "std::string" - is DataType.array -> arrayDataType.getArrayType(type.elementDataType) + is DataType.array -> arrayDataType.getArrayType(type.elementDataType, importsBlock) is DataType.userClass -> type.path is DataType.custom -> type.block.name is DataType.userClassTest2 -> type.node.getPath() diff --git a/cgen-lib/src/main/kotlin/generators/cpp/PrepareRightValueUseCase.kt b/cgen-lib/src/main/kotlin/generators/cpp/PrepareRightValueUseCase.kt index cb3e1e6..a51cec6 100644 --- a/cgen-lib/src/main/kotlin/generators/cpp/PrepareRightValueUseCase.kt +++ b/cgen-lib/src/main/kotlin/generators/cpp/PrepareRightValueUseCase.kt @@ -10,21 +10,19 @@ import generators.obj.abstractSyntaxTree.addSub import generators.obj.syntaxParseTree.ArgumentNode import generators.obj.syntaxParseTree.Arguments import generators.obj.syntaxParseTree.Constructor -import generators.obj.syntaxParseTree.FileData -import generators.obj.syntaxParseTree.Keyword -import generators.obj.syntaxParseTree.VariableName +import generators.obj.syntaxParseTree.ImportsBlock class PrepareRightValueUseCase( private val getTypeNameUseCase: GetTypeNameUseCase ) { - fun toRightValue(dataField: DataField, fileData: FileData): RValue = + fun toRightValue(dataField: DataField, importsBlock: ImportsBlock): RValue = toRightValue( type = dataField.getType(), value = dataField.getValue(), - fileData = fileData + importsBlock = importsBlock, ) - fun toRightValue(type: DataType, value: DataValue, fileData: FileData): RValue = + fun toRightValue(type: DataType, value: DataValue, importsBlock: ImportsBlock): RValue = when (type) { DataType.VOID -> RValue(name = "void") DataType.int8, DataType.int16, DataType.int32, DataType.int64, @@ -50,7 +48,7 @@ class PrepareRightValueUseCase( } else { val valueComplexItem = value.subs.first() if (valueComplexItem is NewInstance) { - prepareConstructor(valueComplexItem, fileData) + prepareConstructor(valueComplexItem, importsBlock) } else { RValue(name = "QQVAL_complex???") } @@ -61,12 +59,12 @@ class PrepareRightValueUseCase( else -> RValue(name = "QQVAL_$type") } - fun prepareConstructor(item: NewInstance, fileData: FileData): RValue { + fun prepareConstructor(item: NewInstance, importsBlock: ImportsBlock): RValue { val result = RValue() result.addSub( Constructor( name = getTypeNameUseCase.typeTo( - file = fileData, + importsBlock = importsBlock, type = item.getType() ) ).apply { @@ -84,7 +82,7 @@ class PrepareRightValueUseCase( toRightValue( type = input.getType(), value = input.getValue(), - fileData = fileData + importsBlock = importsBlock ) ) } diff --git a/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt b/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt index 1cc0aa7..3c34402 100644 --- a/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt +++ b/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt @@ -1,75 +1,92 @@ package generators.cpp import ce.defs.DataType +import generators.obj.syntaxParseTree.ImportsBlock +import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test class GetArrayDataTypeUseCaseTest { private val useCase = GetArrayDataTypeUseCase() + private val importsBlock = ImportsBlock() + + @BeforeEach + fun setup() { + importsBlock.subs.clear() + } + @Test fun getArrayTypeReturnsByteArrayForInt8() { - val result = useCase.getArrayType(DataType.int8) + val result = useCase.getArrayType(DataType.int8, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsByteArrayForUint8() { - val result = useCase.getArrayType(DataType.uint8) + val result = useCase.getArrayType(DataType.uint8, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsShortArrayForInt16() { - val result = useCase.getArrayType(DataType.int16) + val result = useCase.getArrayType(DataType.int16, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsIntArrayForInt32() { - val result = useCase.getArrayType(DataType.int32) + val result = useCase.getArrayType(DataType.int32, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsLongArrayForInt64() { - val result = useCase.getArrayType(DataType.int64) + val result = useCase.getArrayType(DataType.int64, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsShortArrayForUint16() { - val result = useCase.getArrayType(DataType.uint16) + val result = useCase.getArrayType(DataType.uint16, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsIntArrayForUint32() { - val result = useCase.getArrayType(DataType.uint32) + val result = useCase.getArrayType(DataType.uint32, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsFloatArrayForFloat32() { - val result = useCase.getArrayType(DataType.float32) + val result = useCase.getArrayType(DataType.float32, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsDoubleArrayForFloat64() { - val result = useCase.getArrayType(DataType.float64) + val result = useCase.getArrayType(DataType.float64, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsStringArrayForStringType() { - val result = useCase.getArrayType(DataType.string) + val result = useCase.getArrayType(DataType.string, importsBlock) assertEquals("std::vector", result) } @Test fun getArrayTypeReturnsUserClassPathForUserClassType() { val userClassType = DataType.userClass("MyClass") - val result = useCase.getArrayType(userClassType) + val result = useCase.getArrayType(userClassType, importsBlock) assertEquals("std::vector", result) } + + @Test + fun getArrayTypeAddvectorToImports() { + val result = useCase.getArrayType(DataType.float64, importsBlock) + Assertions.assertEquals(1, importsBlock.subs.size) + assertEquals("", importsBlock.subs[0].name) + } } \ No newline at end of file diff --git a/cgen-lib/src/test/java/generators/cpp/GetTypeNameUseCaseTest.kt b/cgen-lib/src/test/java/generators/cpp/GetTypeNameUseCaseTest.kt new file mode 100644 index 0000000..93f35b9 --- /dev/null +++ b/cgen-lib/src/test/java/generators/cpp/GetTypeNameUseCaseTest.kt @@ -0,0 +1,52 @@ +package generators.cpp + +import ce.defs.DataType +import generators.obj.abstractSyntaxTree.findOrCreateSub +import generators.obj.syntaxParseTree.ImportLeaf +import generators.obj.syntaxParseTree.ImportsBlock +import org.junit.jupiter.api.Assertions +import org.junit.jupiter.api.Test + +class GetTypeNameUseCaseTest { + val getArrayDataTypeUseCase = GetArrayDataTypeUseCase() + val useCase = GetTypeNameUseCase(getArrayDataTypeUseCase) + @Test + fun testStringInclude() { + val filedata = CppHeaderFile() + val imports = filedata.findOrCreateSub(ImportsBlock::class.java) + useCase.typeTo(imports, DataType.string) + Assertions.assertTrue(imports.subs.size > 0) + Assertions.assertEquals(ImportLeaf::class.java, imports.subs[0]::class.java) + Assertions.assertEquals("", imports.subs[0].name) + } + + @Test + fun testUintInclude() { + val filedata = CppHeaderFile() + val imports = filedata.findOrCreateSub(ImportsBlock::class.java) + useCase.typeTo(imports, DataType.uint32) + Assertions.assertTrue(imports.subs.size > 0) + Assertions.assertEquals(ImportLeaf::class.java, imports.subs[0]::class.java) + Assertions.assertEquals("", imports.subs[0].name) + } + + @Test + fun testVectorInclude() { + val filedata = CppHeaderFile() + val imports = filedata.findOrCreateSub(ImportsBlock::class.java) + useCase.typeTo(imports, DataType.array(DataType.bool)) + Assertions.assertTrue(imports.subs.size > 0) + Assertions.assertEquals(ImportLeaf::class.java, imports.subs[0]::class.java) + Assertions.assertEquals("", imports.subs[0].name) + } + + @Test + fun testOptionalInclude() { + val filedata = CppHeaderFile() + val imports = filedata.findOrCreateSub(ImportsBlock::class.java) + useCase.typeTo(imports, DataType.boolNullable) + Assertions.assertTrue(imports.subs.size > 0) + Assertions.assertEquals(ImportLeaf::class.java, imports.subs[0]::class.java) + Assertions.assertEquals("", imports.subs[0].name) + } +} \ No newline at end of file diff --git a/cgen-lib/src/test/java/generators/cpp/PrepareRightValueUseCaseTest.kt b/cgen-lib/src/test/java/generators/cpp/PrepareRightValueUseCaseTest.kt index 95f1028..fc231eb 100644 --- a/cgen-lib/src/test/java/generators/cpp/PrepareRightValueUseCaseTest.kt +++ b/cgen-lib/src/test/java/generators/cpp/PrepareRightValueUseCaseTest.kt @@ -7,10 +7,12 @@ import ce.defs.RValue import generators.obj.abstractSyntaxTree.DataClass import generators.obj.abstractSyntaxTree.DataField import generators.obj.abstractSyntaxTree.NewInstance +import generators.obj.abstractSyntaxTree.findOrCreateSub import generators.obj.syntaxParseTree.ArgumentNode import generators.obj.syntaxParseTree.Arguments import generators.obj.syntaxParseTree.Constructor import generators.obj.syntaxParseTree.FileDataImpl +import generators.obj.syntaxParseTree.ImportsBlock import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertTrue @@ -20,54 +22,67 @@ class PrepareRightValueUseCaseTest { private val arrayDataType = GetArrayDataTypeUseCase() private val dataTypeToString = GetTypeNameUseCase(arrayDataType) private val fileData = FileDataImpl(name = "testFile") + private val importsBlock = fileData.findOrCreateSub(ImportsBlock::class.java) private val prepareRightValueUseCase = PrepareRightValueUseCase(dataTypeToString) @Test fun toRightValueReturnsVoidForVoidType() { - val result = prepareRightValueUseCase.toRightValue(DataType.VOID, - DataValueImpl("ignored"), fileData) + val result = prepareRightValueUseCase.toRightValue( + DataType.VOID, + DataValueImpl("ignored"), importsBlock + ) assertEquals("void", result.name) } @Test fun toRightValueReturnsSimpleValueForIntegerTypes() { - val result = prepareRightValueUseCase.toRightValue(DataType.int32, - DataValueImpl(simple = 42), fileData) + val result = prepareRightValueUseCase.toRightValue( + DataType.int32, + DataValueImpl(simple = 42), importsBlock + ) assertEquals("42", result.name) } @Test fun toRightValueAppendsFForFloat32Type() { - val result = prepareRightValueUseCase.toRightValue(DataType.float32, - DataValueImpl(simple = 3.14), fileData) + val result = prepareRightValueUseCase.toRightValue( + DataType.float32, + DataValueImpl(simple = 3.14), importsBlock + ) assertEquals("3.14f", result.name) } @Test fun toRightValueReturnsSimpleValueForFloat64Type() { - val result = prepareRightValueUseCase.toRightValue(DataType.float64, - DataValueImpl(simple = 3.14), fileData) + val result = prepareRightValueUseCase.toRightValue( + DataType.float64, + DataValueImpl(simple = 3.14), importsBlock + ) assertEquals("3.14", result.name) } @Test fun toRightValueReturnsSimpleValueForBooleanType() { - val result = prepareRightValueUseCase.toRightValue(DataType.bool, - DataValueImpl(simple = true), fileData) + val result = prepareRightValueUseCase.toRightValue( + DataType.bool, + DataValueImpl(simple = true), importsBlock + ) assertEquals("true", result.name) } @Test fun toRightValueReturnsSimpleValueForStringType() { - val result = prepareRightValueUseCase.toRightValue(DataType.string, - DataValueImpl(simple = "hello"), fileData) + val result = prepareRightValueUseCase.toRightValue( + DataType.string, + DataValueImpl(simple = "hello"), importsBlock + ) assertEquals("\"hello\"", result.name) } @Test fun toRightValueCustomClass() { val dataClassDescriptor = DataClass("c").apply { - field("A", DataType.int32, 1) + field("A", DataType.int32, 1) } val dataType = DataType.custom(dataClassDescriptor) val instance = NewInstance("newInstance") @@ -79,7 +94,10 @@ class PrepareRightValueUseCaseTest { setType(dataType) } - val result = prepareRightValueUseCase.toRightValue(dataField = field, fileData = fileData) + val result = prepareRightValueUseCase.toRightValue( + dataField = field, + importsBlock = importsBlock + ) assertTrue(result is RValue) } @@ -87,15 +105,15 @@ class PrepareRightValueUseCaseTest { fun testConstructorToAst() { val className = "className" val dataClassDescriptor = DataClass(className).apply { - field("a", DataType.string, "") - field("b", DataType.int32, 0) + field("a", DataType.string, "") + field("b", DataType.int32, 0) } val dataType = DataType.custom(dataClassDescriptor) val instance = dataClassDescriptor.instance( mapOf("a" to "defined", "b" to 123) ) - val result = prepareRightValueUseCase.prepareConstructor(instance, fileData) + val result = prepareRightValueUseCase.prepareConstructor(instance, importsBlock) // expected result // // diff --git a/test/enumGoldErrors.groovy b/test/enumGoldErrors.groovy index 46b9d02..5426a3a 100644 --- a/test/enumGoldErrors.groovy +++ b/test/enumGoldErrors.groovy @@ -19,6 +19,11 @@ ns.dataClass("GroovyData").tap { field("age", DataType.int32.INSTANCE, 35) } +ns.dataClass("GroovyData2").tap { + field("age", DataType.int32.INSTANCE, 35) + field("names", new DataType.array(DataType.string.INSTANCE, false)) +} + def styxQid = ns.dataClass("Qid") styxQid.with { addBlockComment("QID structure") From c288befef92203b8764c41d7dad46d72510873be Mon Sep 17 00:00:00 2001 From: "V.Shkriabets" Date: Mon, 27 Oct 2025 22:47:44 +0200 Subject: [PATCH 2/2] Fix comments --- .../src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt | 6 ++---- .../test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt | 2 +- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt b/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt index 0f2c4ae..110c477 100644 --- a/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt +++ b/cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt @@ -32,7 +32,7 @@ class GetTypeNameUseCase( DataType.uint8Nullable, DataType.uint16Nullable, DataType.uint32Nullable, - DataType.uint64Nullable-> { + DataType.uint64Nullable -> { importsBlock.addInclude("") } DataType.string, DataType.stringNullable -> { @@ -41,9 +41,7 @@ class GetTypeNameUseCase( is DataType.array -> { importsBlock.addInclude("") } - else -> { - - } + else -> {} } if (type.canBeNull) { importsBlock.addInclude("") diff --git a/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt b/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt index 3c34402..75987d2 100644 --- a/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt +++ b/cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt @@ -84,7 +84,7 @@ class GetArrayDataTypeUseCaseTest { } @Test - fun getArrayTypeAddvectorToImports() { + fun getArrayTypeAddsVectorToImports() { val result = useCase.getArrayType(DataType.float64, importsBlock) Assertions.assertEquals(1, importsBlock.subs.size) assertEquals("", importsBlock.subs[0].name)