Fix #653 (#690)

* Fixed

* Cleaned

* Fixed

* Fixed implicit item bug

* Fixed escaping

rosetta-lang/src/main/java/com/regnosys/rosetta/parsing/RosettaValueConverterService.java

@@ -11,9 +11,15 @@
 import org.eclipse.xtext.conversion.ValueConverter;
 
 public class RosettaValueConverterService extends DefaultTerminalConverters {
-	@Inject BigIntegerConverter bigIntegerConverter;
-	@Inject BigDecimalConverter bigDecimalConverter;
-	@Inject PATTERNValueConverter patternValueConverter;
+	@Inject private ValidIDConverter validIDValueConverter;
+	@Inject private BigIntegerConverter bigIntegerConverter;
+	@Inject private BigDecimalConverter bigDecimalConverter;
+	@Inject private PATTERNValueConverter patternValueConverter;
+
+	@ValueConverter(rule = "ValidID")
+	public IValueConverter<String> getValidIDConverter() {
+		return validIDValueConverter;
+	}
 
 	@ValueConverter(rule = "Integer")
 	public IValueConverter<BigInteger> getBigIntegerConverter() {

rosetta-lang/src/main/java/com/regnosys/rosetta/parsing/ValidIDConverter.java

@@ -0,0 +1,51 @@
+package com.regnosys.rosetta.parsing;
+
+import java.util.Set;
+
+import javax.inject.Inject;
+
+import org.eclipse.xtext.Alternatives;
+import org.eclipse.xtext.Keyword;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.conversion.ValueConverterException;
+import org.eclipse.xtext.conversion.impl.AbstractValueConverter;
+import org.eclipse.xtext.conversion.impl.IDValueConverter;
+import org.eclipse.xtext.nodemodel.INode;
+
+import com.google.common.collect.ImmutableSet;
+import com.regnosys.rosetta.services.RosettaGrammarAccess;
+
+/**
+ * Allows using a caret `^` to escape identifiers based on the `ValidID` rule. 
+ * 
+ * Similar implementation to {@link org.eclipse.xtext.conversion.impl.IDValueConverter}.
+ */
+public class ValidIDConverter extends AbstractValueConverter<String> {
+	private final ParserRule validIDRule;
+	private final Set<String> validKeywordIDs;
+	private final IDValueConverter delegate;
+	@Inject
+	public ValidIDConverter(RosettaGrammarAccess grammarAccess, IDValueConverter delegate) {
+		this.validIDRule = grammarAccess.getValidIDRule();
+		this.delegate = delegate;
+
+		// We expect the ValidID rule to be of the form `ID | <list of keywords>`
+		Alternatives alternatives = (Alternatives) validIDRule.getAlternatives();
+		ImmutableSet.Builder<String> builder = ImmutableSet.builder();
+		alternatives.getElements().stream().skip(1).forEach(element -> builder.add(((Keyword)element).getValue()));
+		validKeywordIDs = builder.build();
+	}
+
+	@Override
+	public String toValue(String string, INode node) {
+		return delegate.toValue(string, node);
+	}
+
+	@Override
+	public String toString(String value) throws ValueConverterException {
+		if (validKeywordIDs.contains(value)) {
+			return value;
+		}
+		return delegate.toString(value);
+	}
+}

rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/function/FunctionGeneratorTest.xtend

@@ -41,6 +41,61 @@ class FunctionGeneratorTest {
 	@Inject extension ModelHelper
 	@Inject extension ValidationTestHelper
 
+	@Test
+	def void canEscapeIdentifiers() {
+		val code = '''
+		func Foo:
+			inputs: ^func int (1..1)
+			output: result int (1..1)
+			set result:
+				^func
+		'''.generateCode
+
+		val funcCode = code.get("com.rosetta.test.model.functions.Foo")
+		assertEquals(
+			'''
+			package com.rosetta.test.model.functions;
+			
+			import com.google.inject.ImplementedBy;
+			import com.rosetta.model.lib.functions.RosettaFunction;
+			
+			
+			@ImplementedBy(Foo.FooDefault.class)
+			public abstract class Foo implements RosettaFunction {
+			
+				/**
+				* @param func 
+				* @return result 
+				*/
+				public Integer evaluate(Integer func) {
+					Integer result = doEvaluate(func);
+					
+					return result;
+				}
+			
+				protected abstract Integer doEvaluate(Integer func);
+			
+				public static class FooDefault extends Foo {
+					@Override
+					protected Integer doEvaluate(Integer func) {
+						Integer result = null;
+						return assignOutput(result, func);
+					}
+					
+					protected Integer assignOutput(Integer result, Integer func) {
+						result = func;
+						
+						return result;
+					}
+				}
+			}
+			'''.toString,
+			funcCode
+		)
+
+		code.compileToClasses
+	}
+
 	@Test
 	def void canReturnEmptyInsideExtract() {
 		val code = '''