From 9b11a92309a03d745c52a208e590a683f84f4cf8 Mon Sep 17 00:00:00 2001
From: SimonCockx <47859223+SimonCockx@users.noreply.github.com>
Date: Fri, 7 Mar 2025 16:49:45 +0100
Subject: [PATCH] Fix default operation issue (#948)

* Fix default operation issue

* clean

* Fixed
---
 .../expression/ExpressionGeneratorTest.xtend  | 22 ++++++++++++
 .../java/expression/ExpressionGenerator.xtend | 36 ++++++++++++-------
 2 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/expression/ExpressionGeneratorTest.xtend b/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/expression/ExpressionGeneratorTest.xtend
index 2ede54d3b..831a34376 100644
--- a/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/expression/ExpressionGeneratorTest.xtend
+++ b/rosetta-integration-tests/src/test/java/com/regnosys/rosetta/generator/java/expression/ExpressionGeneratorTest.xtend
@@ -71,6 +71,28 @@ class ExpressionGeneratorTest {
 	
 
 	
+	@Test
+	def void testDefaultWithMetaCoercion() {
+		val expr = '''
+		foo default bar
+		'''
+		
+		val expected = '''
+		import com.rosetta.model.lib.mapper.MapperS;
+		import com.rosetta.model.metafields.FieldWithMetaString;
+		
+		
+		{
+			FieldWithMetaString foo;
+			FieldWithMetaString bar;
+			final FieldWithMetaString fieldWithMetaString = MapperS.of(foo).getOrDefault(bar);
+			return fieldWithMetaString == null ? null : fieldWithMetaString.getValue();
+		}
+		'''
+		
+		assertJavaCode(expected, expr, String, #[], #["foo string (1..1) [metadata scheme]", "bar string (1..1) [metadata scheme]"])
+	}
+	
 	@Test
 	def void testFeatureCallToIncompatibleOverrideUsesCorrectGetter() {
 		val context = '''
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend
index a3cf164ba..f34458d79 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend
@@ -346,12 +346,6 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	private def binaryExpr(RosettaBinaryOperation expr, Context context) {
 		val left = expr.left
 		val right = expr.right
-		val leftRtype = typeProvider.getRMetaAnnotatedType(expr.left).RType
-		val rightRtype = typeProvider.getRMetaAnnotatedType(expr.right).RType
-		val joined = leftRtype.join(rightRtype).toJavaReferenceType
-		val resultType = typeProvider.getRMetaAnnotatedType(expr).toJavaReferenceType
-		val leftType = leftRtype.toJavaReferenceType
-		val rightType = rightRtype.toJavaReferenceType
 
 		switch expr.operator {
 			case "and",
@@ -365,6 +359,12 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			case "-",
 			case "*",
 			case "/": {
+				val leftRtype = typeProvider.getRMetaAnnotatedType(expr.left).RType
+				val rightRtype = typeProvider.getRMetaAnnotatedType(expr.right).RType
+				val leftType = leftRtype.toJavaReferenceType
+				val rightType = rightRtype.toJavaReferenceType
+				val joinedWithoutMeta = leftRtype.join(rightRtype).toJavaReferenceType
+				val resultType = typeProvider.getRMetaAnnotatedType(expr).toJavaReferenceType
 				val method = switch expr.operator {
 					case "+": "add"
 					case "-": "subtract"
@@ -372,10 +372,10 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 					case "/": "divide"
 				}
 				if (leftType.extendsNumber && rightType.extendsNumber) {
-					val leftCode = javaCode(left, MAPPER.wrapExtends(joined), context.scope)
-					val rightCode = javaCode(right, MAPPER.wrapExtends(joined), context.scope)
+					val leftCode = javaCode(left, MAPPER.wrapExtends(joinedWithoutMeta), context.scope)
+					val rightCode = javaCode(right, MAPPER.wrapExtends(joinedWithoutMeta), context.scope)
 					leftCode
-						.then(rightCode, [l, r|JavaExpression.from('''«MapperMaths».<«resultType», «joined», «joined»>«method»(«l», «r»)''', MAPPER_S.wrap(resultType))], context.scope)
+						.then(rightCode, [l, r|JavaExpression.from('''«MapperMaths».<«resultType», «joinedWithoutMeta», «joinedWithoutMeta»>«method»(«l», «r»)''', MAPPER_S.wrap(resultType))], context.scope)
 				} else {
 					val leftCode = javaCode(left, MAPPER.wrapExtends(leftType), context.scope)
 					val rightCode = javaCode(right, MAPPER.wrapExtends(rightType), context.scope)
@@ -385,12 +385,20 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			}
 			case "contains",
 			case "disjoint": {
+				val leftRMetaType = typeProvider.getRMetaAnnotatedType(expr.left)
+				val rightRMetaType = typeProvider.getRMetaAnnotatedType(expr.right)
+				val joined = leftRMetaType.joinMetaAnnotatedTypes(rightRMetaType).toJavaReferenceType
+				
 				val leftCode = javaCode(left, MAPPER.wrapExtends(joined), context.scope)
 				val rightCode = javaCode(right, MAPPER.wrapExtends(joined), context.scope)
 				leftCode
 					.then(rightCode, [l, r|JavaExpression.from('''«runtimeMethod(expr.operator)»(«l», «r»)''', COMPARISON_RESULT)], context.scope)
 			}
 			case "default": {
+				val leftRMetaType = typeProvider.getRMetaAnnotatedType(expr.left)
+				val rightRMetaType = typeProvider.getRMetaAnnotatedType(expr.right)
+				val joined = leftRMetaType.joinMetaAnnotatedTypes(rightRMetaType).toJavaReferenceType
+				
 				val leftCode = javaCode(left, MAPPER.wrapExtends(joined), context.scope)
 				if (left.isMulti) {
 					val rightCode = javaCode(right, MAPPER.wrapExtends(joined), context.scope)
@@ -398,6 +406,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 					leftCode
 					.then(rightCode, [l, r| new JavaConditionalExpression(JavaExpression.from('''«l».getMulti().isEmpty()''', JavaPrimitiveType.BOOLEAN),r ,l , typeUtil)], context.scope)
 				} else {
+					val resultType = typeProvider.getRMetaAnnotatedType(expr).toJavaReferenceType
 					val rightCode = javaCode(right, joined, context.scope)
 					
 					leftCode
@@ -406,7 +415,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			}
 			case "join": {
 				val leftCode = javaCode(left, MAPPER_C.wrapExtends(STRING), context.scope)
-				val rightCode = expr.right === null ? JavaExpression.from('''«MapperS».of("")''', resultType) : javaCode(right, MAPPER_S.wrap(STRING), context.scope)
+				val rightCode = expr.right === null ? JavaExpression.from('''«MapperS».of("")''', MAPPER_S.wrap(STRING)) : javaCode(right, MAPPER_S.wrap(STRING), context.scope)
 				leftCode
 					.then(rightCode, [l, r|JavaExpression.from('''«l».join(«r»)''', MAPPER_S.wrap(STRING))], context.scope)
 			}
@@ -416,6 +425,9 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			case "<=",
 			case ">",
 			case ">=": {
+				val leftRtype = typeProvider.getRMetaAnnotatedType(expr.left).RType
+				val rightRtype = typeProvider.getRMetaAnnotatedType(expr.right).RType
+				val joinedWithoutMeta = leftRtype.join(rightRtype).toJavaReferenceType
 				val method = switch expr.operator {
 					case "=": 'areEqual'
 					case "<>": 'notEqual'
@@ -430,8 +442,8 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 				} else {
 					CardinalityModifier.ALL
 				}
-				val leftCode = javaCode(left, MAPPER.wrapExtends(joined), context.scope)
-				val rightCode = javaCode(right, MAPPER.wrapExtends(joined), context.scope)
+				val leftCode = javaCode(left, MAPPER.wrapExtends(joinedWithoutMeta), context.scope)
+				val rightCode = javaCode(right, MAPPER.wrapExtends(joinedWithoutMeta), context.scope)
 				leftCode
 					.then(rightCode, [l, r|JavaExpression.from('''«runtimeMethod(method)»(«l», «r», «toCardinalityOperator(modifier, defaultModifier)»)''', COMPARISON_RESULT)], context.scope)
 			}