Change universal type variables to existential in requested value types
[simantics/platform.git] / bundles / org.simantics.document.server / src / org / simantics / document / server / request / ServerSCLValueRequest.java
1 package org.simantics.document.server.request;
2
3 import java.util.ArrayList;
4 import java.util.Map;
5
6 import org.simantics.databoard.Bindings;
7 import org.simantics.db.ReadGraph;
8 import org.simantics.db.Resource;
9 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
10 import org.simantics.db.common.request.IndexRoot;
11 import org.simantics.db.common.request.UnaryRead;
12 import org.simantics.db.exception.DatabaseException;
13 import org.simantics.db.layer0.scl.AbstractExpressionCompilationContext;
14 import org.simantics.db.layer0.scl.AbstractExpressionCompilationRequest;
15 import org.simantics.db.layer0.util.RuntimeEnvironmentRequest2;
16 import org.simantics.db.layer0.variable.Variable;
17 import org.simantics.document.server.request.ServerSCLValueRequest.CompilationContext;
18 import org.simantics.layer0.Layer0;
19 import org.simantics.scl.compiler.common.names.Name;
20 import org.simantics.scl.compiler.constants.StringConstant;
21 import org.simantics.scl.compiler.elaboration.expressions.EApply;
22 import org.simantics.scl.compiler.elaboration.expressions.EConstant;
23 import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
24 import org.simantics.scl.compiler.elaboration.expressions.EVariable;
25 import org.simantics.scl.compiler.elaboration.expressions.Expression;
26 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
27 import org.simantics.scl.compiler.environment.Environment;
28 import org.simantics.scl.compiler.environment.Environments;
29 import org.simantics.scl.compiler.environment.specification.EnvironmentSpecification;
30 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
31 import org.simantics.scl.compiler.top.SCLExpressionCompilationException;
32 import org.simantics.scl.compiler.types.TMetaVar;
33 import org.simantics.scl.compiler.types.TVar;
34 import org.simantics.scl.compiler.types.Type;
35 import org.simantics.scl.compiler.types.Types;
36 import org.simantics.scl.compiler.types.kinds.Kinds;
37 import org.simantics.scl.runtime.SCLContext;
38 import org.simantics.scl.runtime.function.Function1;
39 import org.simantics.structural2.scl.ComponentTypeProperty;
40 import org.simantics.structural2.scl.FindPossibleComponentTypeRequest;
41 import org.simantics.structural2.scl.ReadComponentTypeInterfaceRequest;
42 import org.simantics.utils.datastructures.Pair;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
45
46 public class ServerSCLValueRequest extends AbstractExpressionCompilationRequest<CompilationContext, Variable> {
47
48     private static final Logger LOGGER = LoggerFactory.getLogger(ServerSCLValueRequest.class);
49     
50         private final Pair<Resource,Resource> componentTypeAndRoot;
51         private final Resource literal;
52     protected String possibleExpectedValueType;
53
54         public static class CompilationContext extends AbstractExpressionCompilationContext {
55                 public final Map<String, ComponentTypeProperty> propertyMap;
56
57                 public CompilationContext(RuntimeEnvironment runtimeEnvironment,
58                                 Map<String, ComponentTypeProperty> propertyMap) {
59                         super(runtimeEnvironment);
60                         this.propertyMap = propertyMap;
61                 }
62         }
63
64         private ServerSCLValueRequest(Pair<Resource,Resource> componentTypeAndRoot, Resource literal, String possibleExpectedValueType) {
65                 assert(literal != null);
66                 this.literal = literal;
67                 this.componentTypeAndRoot = componentTypeAndRoot;
68                 this.possibleExpectedValueType = possibleExpectedValueType;
69         }
70
71         public ServerSCLValueRequest(ReadGraph graph, Variable context) throws DatabaseException {
72                 this(getComponentTypeAndRoot(graph, context), context.getRepresents(graph), resolveExpectedValueType(graph, context));
73         }
74
75         private static Pair<Resource,Resource> getComponentTypeAndRoot(ReadGraph graph, Variable property)  throws DatabaseException {
76                 Variable parent = property.getParent(graph);
77                 Resource represents = parent.getRepresents(graph);
78                 if(represents != null) {
79                         Resource type = graph.syncRequest(new FindPossibleComponentTypeRequest(represents));
80                         if(type != null) {
81                                 Resource root = graph.syncRequest(new IndexRoot(type));
82                                 return Pair.make(type, root);
83                         }
84                 }
85                 parent = parent.getParent(graph);
86                 Resource root = graph.syncRequest(new IndexRoot(property.getRepresents(graph)));
87                 return Pair.make(parent.getType(graph), root);
88         }
89
90         public static Object compileAndEvaluate(ReadGraph graph, Variable context) throws DatabaseException {
91                 SCLContext sclContext = SCLContext.getCurrent();
92         Object oldGraph = sclContext.get("graph");
93                 try {
94                         Function1<Variable,Object> exp = graph.syncRequest(new ServerSCLValueRequest(graph, context),
95                                         TransientCacheListener.<Function1<Variable,Object>>instance());
96                         sclContext.put("graph", graph);
97                         return exp.apply(context);
98                 } catch (DatabaseException e) {
99                         throw (DatabaseException)e;
100                 } catch (Throwable t) {
101                         throw new DatabaseException(t);
102                 } finally {
103             sclContext.put("graph", oldGraph);
104                 }
105         }
106
107         @Override
108         protected String getExpressionText(ReadGraph graph)
109                         throws DatabaseException {
110                 Layer0 L0 = Layer0.getInstance(graph);
111                 return graph.getRelatedValue(literal, L0.SCLValue_expression, Bindings.STRING);
112         }
113
114         protected RuntimeEnvironmentRequest2 getRuntimeEnvironmentRequest(Resource componentType, Resource indexRoot) {
115                 return new RuntimeEnvironmentRequest2(componentType, indexRoot) {
116                         @Override
117                         protected void fillEnvironmentSpecification(
118                                         EnvironmentSpecification environmentSpecification) {
119                         }
120                 };
121         }
122
123         @Override
124         protected CompilationContext getCompilationContext(ReadGraph graph)
125                         throws DatabaseException {
126                 return graph.syncRequest(new UnaryRead<Pair<Resource,Resource>,CompilationContext>(componentTypeAndRoot) {
127                         @Override
128                         public CompilationContext perform(ReadGraph graph)
129                                         throws DatabaseException {
130                                 RuntimeEnvironment runtimeEnvironment = graph.syncRequest(getRuntimeEnvironmentRequest(parameter.first, parameter.second));
131                                 Map<String, ComponentTypeProperty> propertyMap =
132                                                 graph.syncRequest(new ReadComponentTypeInterfaceRequest(parameter.first, runtimeEnvironment.getEnvironment()),
133                                                                 TransientCacheListener.<Map<String, ComponentTypeProperty>>instance());
134                                 return new CompilationContext(runtimeEnvironment, propertyMap);
135                         }
136                 });
137         }
138
139         @Override
140         protected Type getContextVariableType() {
141                 return VARIABLE; 
142         }
143
144         private static Expression accessInputVariable(Environment environment,
145                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable) {
146                 SCLValue variableParentFunction = environment.getValue(VARIABLE_PARENT);
147                 return new EApply(new EConstant(variableParentFunction),
148                                 new EApply(new EConstant(variableParentFunction),
149                                                 new EVariable(contextVariable)));
150         }
151
152     protected static Name PROPERTY_VALUE_CACHED = Name.create("Document/All", "propertyValueCached");
153
154     protected static Expression getProperty(Environment environment, Expression variable, String propertyName, Type type) {
155         return new EApply(
156                 new EConstant(environment.getValue(FROM_DYNAMIC), type),
157                 new EApply(
158                         new EConstant(environment.getValue(PROPERTY_VALUE_CACHED), Types.DYNAMIC),
159                         variable,
160                         new ELiteral(new StringConstant(propertyName))));
161     }
162     
163     protected static Expression getPropertyFlexible(Environment environment, Expression variable, String propertyName, Type type) {
164         return makeTypeFlexible(environment, getProperty(environment, variable, propertyName, type), type);
165     }
166         
167         protected static Expression standardGetProperty(
168                         Environment environment,
169                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,
170                         String name,
171                         Type type) {
172                 return getPropertyFlexible(environment, accessInputVariable(environment, contextVariable), name, type);
173         }
174
175
176         @Override
177         protected Expression getVariableAccessExpression(
178                         ReadGraph graph,
179                         CompilationContext context,
180                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,
181                         String name) throws DatabaseException {
182                 ComponentTypeProperty property = context.propertyMap.get(name);
183                 if(property != null)
184                         return standardGetProperty(
185                                         context.runtimeEnvironment.getEnvironment(),
186                                         contextVariable,
187                                         name,
188                                         property.type == null ? Types.metaVar(Kinds.STAR) : property.type);
189                 else
190                         return getSpecialVariableAccessExpression(graph, context, contextVariable, name);
191         }
192
193         protected Expression getSpecialVariableAccessExpression(ReadGraph graph,
194                         CompilationContext context,
195                         org.simantics.scl.compiler.elaboration.expressions.Variable contextVariable,
196                         String name) throws DatabaseException {
197                 if(name.equals("input")) {
198                         Environment environment = context.runtimeEnvironment.getEnvironment();
199                         return accessInputVariable(environment, contextVariable);
200                 }
201                 else if(name.equals("self"))
202                         return new EVariable(contextVariable);
203                 else
204                         return null;
205         }
206         
207     @Override
208     protected Type getExpectedType(ReadGraph graph, CompilationContext context) throws DatabaseException {
209         if(possibleExpectedValueType != null) {
210             try {
211                 Type type = Environments.getType(context.runtimeEnvironment.getEnvironment(), possibleExpectedValueType);
212                 type = Types.instantiate(Types.forAll(Types.freeVars(type).toArray(new TVar[0]), type), new ArrayList<TMetaVar>());
213                 return type;
214             } catch (SCLExpressionCompilationException e) {
215                 LOGGER.error("Could not get type for " + String.valueOf(possibleExpectedValueType), e);
216             }
217         }
218         return super.getExpectedType(graph, context);
219     }
220
221
222         @Override
223         public int hashCode() {
224                 return 31*(31*getClass().hashCode() + literal.hashCode()) + componentTypeAndRoot.hashCode();
225         }
226
227         @Override
228         public boolean equals(Object obj) {
229                 if(this == obj)
230                         return true;
231                 if(obj == null || obj.getClass() != getClass())
232                         return false;
233                 ServerSCLValueRequest other = (ServerSCLValueRequest)obj;
234                 return literal.equals(other.literal) && componentTypeAndRoot.equals(other.componentTypeAndRoot);
235         }
236 }