Add fromJson function and explicit conversion

Author: opatrascoiu

dmn-core/src/main/java/com/gs/dmn/el/synthesis/triple/AsTriple.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2016 Goldman Sachs.
+ *
+ * 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 com.gs.dmn.el.synthesis.triple;
+
+import com.gs.dmn.el.analysis.semantics.type.Type;
+
+public class AsTriple extends Triple {
+    private final Triple leftOperand;
+    private final Type rightOperandType;
+    private final String nativeType;
+
+    AsTriple(Triple leftOperand, Type rightOperandType, String nativeType) {
+        this.leftOperand = leftOperand;
+        this.rightOperandType = rightOperandType;
+        this.nativeType = nativeType;
+    }
+
+    Triple getLeftOperand() {
+        return leftOperand;
+    }
+
+    Type getRightOperandType() {
+        return rightOperandType;
+    }
+
+    public String getNativeType() {
+        return nativeType;
+    }
+
+    @Override
+    public <C, R> R accept(Visitor<C, R> visitor, C context) {
+        return visitor.visit(this, context);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("As(%s, %s)", leftOperand, rightOperandType);
+    }
+}

dmn-core/src/main/java/com/gs/dmn/el/synthesis/triple/InstanceOfTriple.java

@@ -17,10 +17,12 @@
 public class InstanceOfTriple extends Triple {
     private final Triple leftOperand;
     private final Type rightOperandType;
+    private final String nativeType;
 
-    InstanceOfTriple(Triple leftOperand, Type rightOperandType) {
+    InstanceOfTriple(Triple leftOperand, Type rightOperandType, String nativeType) {
         this.leftOperand = leftOperand;
         this.rightOperandType = rightOperandType;
+        this.nativeType = nativeType;
     }
 
     Triple getLeftOperand() {
@@ -31,6 +33,10 @@ Type getRightOperandType() {
         return rightOperandType;
     }
 
+    public String getNativeType() {
+        return nativeType;
+    }
+
     @Override
     public <C, R> R accept(Visitor<C, R> visitor, C context) {
         return visitor.visit(this, context);

dmn-core/src/main/java/com/gs/dmn/el/synthesis/triple/TripleSerializerToString.java

@@ -296,7 +296,13 @@ public String visit(SomeTriple triple, Triples context) {
     @Override
     public String visit(InstanceOfTriple triple, Triples context) {
         String operandText = triple.getLeftOperand().accept(this, context);
-        return this.nativeFactory.makeInstanceOf(operandText, triple.getRightOperandType());
+        return this.nativeFactory.makeInstanceOf(operandText, triple.getRightOperandType(), triple.getNativeType());
+    }
+
+    @Override
+    public String visit(AsTriple triple, Triples context) {
+        String operandText = triple.getLeftOperand().accept(this, context);
+        return this.nativeFactory.makeAsType(operandText, triple.getRightOperandType(), triple.getNativeType());
     }
 
     @Override
@@ -314,4 +320,9 @@ public String visit(TripleReference triple, Triples context) {
     public String visit(TextTriple triple, Triples context) {
         return triple.getText();
     }
+
+    @Override
+    public String visit(TypeExpressionTriple triple, Triples context) {
+        return this.nativeFactory.makeTypeReference(triple.getType(), triple.getNativeTypeQName());
+    }
 }

dmn-core/src/main/java/com/gs/dmn/el/synthesis/triple/Triples.java

@@ -73,6 +73,11 @@ public Triple dateTimeLiteral(com.gs.dmn.feel.analysis.syntax.ast.expression.lit
         return addTriple(triple);
     }
 
+    public Triple typeExpression(Type type, String nativeTypeQName) {
+        Triple triple = new TypeExpressionTriple(type, nativeTypeQName);
+        return addTriple(triple);
+    }
+
     public Triple nullLiteral() {
         Triple triple = new NullLiteral();
         return addTriple(triple);
@@ -263,8 +268,13 @@ public Triple makeEveryExpression(Triple forList) {
         return addTriple(triple);
     }
 
-    public Triple makeInstanceOf(Triple leftOperand, Type rightOperandType) {
-        Triple triple = new InstanceOfTriple(leftOperand, rightOperandType);
+    public Triple makeInstanceOf(Triple leftOperand, Type rightOperandType, String nativeType) {
+        Triple triple = new InstanceOfTriple(leftOperand, rightOperandType, nativeType);
+        return addTriple(triple);
+    }
+
+    public Triple makeAs(Triple leftOperand, Type rightOperandType, String nativeType) {
+        Triple triple = new AsTriple(leftOperand, rightOperandType, nativeType);
         return addTriple(triple);
     }
 

dmn-core/src/main/java/com/gs/dmn/el/synthesis/triple/TypeExpressionTriple.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016 Goldman Sachs.
+ *
+ * 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 com.gs.dmn.el.synthesis.triple;
+
+import com.gs.dmn.el.analysis.semantics.type.Type;
+
+public class TypeExpressionTriple extends Triple {
+    private final Type type;
+    private final String nativeTypeQName;
+
+    TypeExpressionTriple(Type type, String nativeTypeQName) {
+        this.type = type;
+        this.nativeTypeQName = nativeTypeQName;
+    }
+
+    Type getType() {
+        return type;
+    }
+
+    public String getNativeTypeQName() {
+        return nativeTypeQName;
+    }
+
+    @Override
+    public <C, R> R accept(Visitor<C, R> visitor, C context) {
+        return visitor.visit(this, context);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("TypeOf(%s)", type);
+    }
+}

dmn-core/src/main/java/com/gs/dmn/el/synthesis/triple/Visitor.java

@@ -97,9 +97,13 @@ public interface Visitor<C, R> {
 
     R visit(InstanceOfTriple triple, C context);
 
+    R visit(AsTriple triple, C context);
+
     R visit(LazyEvaluationTriple triple, C context);
 
     R visit(TripleReference triple, C context);
 
     R visit(TextTriple triple, C context);
+
+    R visit(TypeExpressionTriple triple, C context);
 }

dmn-core/src/main/java/com/gs/dmn/feel/analysis/semantics/FEELSemanticVisitor.java

@@ -518,6 +518,18 @@ public Element<Type> visit(InstanceOfExpression<Type> element, DMNContext contex
         return element;
     }
 
+    @Override
+    public Element<Type> visit(AsExpression<Type> element, DMNContext context) {
+        // Visit children
+        element.getLeftOperand().accept(this, context);
+        element.getRightOperand().accept(this, context);
+
+        // Derive type
+        element.setType(element.getRightOperand().getType());
+
+        return element;
+    }
+
     //
     // Expressions
     //

dmn-core/src/main/java/com/gs/dmn/feel/analysis/semantics/FunctionInvocationUtils.java

@@ -142,6 +142,9 @@ private static Type refineFunctionType(FunctionInvocation<Type> element, Declara
             Type listType = parameters.getParameterType(0, "list");
             Type functionType = parameters.getParameterType(1, "function");
             return StandardEnvironmentFactory.makeSortBuiltinFunctionType(listType, functionType);
+        } else if ("fromJson".equals(functionName)) {
+            Expression<Type> secondParameter = parameters.getParameter(1, "type");
+            return StandardEnvironmentFactory.makeFromJsonBuiltinFunctionType(secondParameter.getType());
         } else if ("range".equals(functionName)) {
             Expression<Type> from = parameters.getParameter(0, "from");
             Type returnType = ANY;

dmn-core/src/main/java/com/gs/dmn/feel/analysis/semantics/environment/StandardEnvironmentFactory.java

@@ -133,6 +133,10 @@ public static BuiltinFunctionType makeRangeBuiltinFunctionType(Type returnType)
         return new BuiltinFunctionType(new RangeType(returnType), new FormalParameter<>("from", STRING));
     }
 
+    public static BuiltinFunctionType makeFromJsonBuiltinFunctionType(Type returnType) {
+        return new BuiltinFunctionType(returnType, new FormalParameter<>("string", STRING), new FormalParameter<>("type", ANY));
+    }
+
     // Signavio
     private static boolean isLibraryFunction(Type originalFunctionType) {
         return originalFunctionType instanceof LibraryFunctionType;
@@ -272,6 +276,8 @@ private static void addBooleanFunctions(Environment environment) {
     }
 
     private static void addStringFunctions(Environment environment) {
+        addFunctionDeclaration(environment, "fromJson", makeFromJsonBuiltinFunctionType(ANY));
+        addFunctionDeclaration(environment, "fromJson1", new BuiltinFunctionType(CONTEXT, new FormalParameter<>("string", STRING)));
         addFunctionDeclaration(environment, "substring", new BuiltinFunctionType(STRING, new FormalParameter<>("string", STRING), new FormalParameter<>("start position", NUMBER), new FormalParameter<>("length", NUMBER, true, false)));
         addFunctionDeclaration(environment, "string length", new BuiltinFunctionType(NUMBER, new FormalParameter<>("string", STRING)));
         addFunctionDeclaration(environment, "upper case", new BuiltinFunctionType(STRING, new FormalParameter<>("string", STRING)));

dmn-core/src/main/java/com/gs/dmn/feel/analysis/semantics/type/DataType.java

@@ -30,6 +30,11 @@ public boolean hasConversionFunction(String kind) {
 
     @Override
     public String typeExpression() {
-        return getName();
+        String name = getName();
+        if (name.indexOf(' ') != -1) {
+            return String.format("'%s'", name);
+        } else {
+            return name;
+        }
     }
 }