Refactored execution slot resolver to only have one resolve method.

plugins/org.yakindu.sct.simulation.core.sexec/src/org/yakindu/sct/simulation/core/sexec/interpreter/DefaultExecutionSlotResolver.xtend

@@ -17,18 +17,16 @@ import org.eclipse.xtext.naming.IQualifiedNameProvider
 import org.eclipse.xtext.util.SimpleAttributeResolver
 import org.yakindu.base.expressions.expressions.AssignmentExpression
 import org.yakindu.base.expressions.expressions.ElementReferenceExpression
-import org.yakindu.base.expressions.expressions.Expression
 import org.yakindu.base.expressions.expressions.FeatureCall
 import org.yakindu.base.types.Event
 import org.yakindu.base.types.Operation
 import org.yakindu.base.types.Property
+import org.yakindu.sct.model.stext.stext.InterfaceScope
 import org.yakindu.sct.model.stext.stext.VariableDefinition
 import org.yakindu.sct.simulation.core.sruntime.CompositeSlot
 import org.yakindu.sct.simulation.core.sruntime.ExecutionContext
-import org.yakindu.sct.simulation.core.sruntime.ExecutionEvent
 import org.yakindu.sct.simulation.core.sruntime.ExecutionSlot
 import org.yakindu.sct.simulation.core.sruntime.ExecutionVariable
-import org.yakindu.sct.model.stext.stext.InterfaceScope
 
 /**
  * Default implementation for resolving execution slots based on expressions.
@@ -46,7 +44,7 @@ class DefaultExecutionSlotResolver implements IExecutionSlotResolver {
 		}
 		if (e.feature instanceof Operation) {
 			// for operation return the execution variable of the operation call's owner on which the operation is to be executed
-			return context.resolveVariable(e.owner)
+			return context.resolve(e.owner)
 		}
 		if (e.feature instanceof Property || e.feature instanceof Event) {
 			var current = e
@@ -92,49 +90,10 @@ class DefaultExecutionSlotResolver implements IExecutionSlotResolver {
 	def dispatch ExecutionSlot resolve(ExecutionContext context, ElementReferenceExpression e) {
 		context.getSlot(e.reference.fullyQualifiedName.toString)
 	}
-
-	def dispatch ExecutionSlot resolveVariable(ExecutionContext context, ElementReferenceExpression e) {
-		val resolved = resolve(context, e)
-		if (resolved.isVariable) {
-			return resolved
-		}
-	}
-
-	def dispatch ExecutionSlot resolveVariable(ExecutionContext context, FeatureCall e) {
-		val resolved = resolve(context, e)
-		if (resolved.isVariable) {
-			return resolved
-		}
-	}
 	
 	def dispatch ExecutionSlot resolve(ExecutionContext context, AssignmentExpression e) {
 		return context.resolve(e.varRef)
 	}
-
-	def dispatch resolveEvent(ExecutionContext context, FeatureCall call) {
-		var resolved = resolve(context, call)
-		if (resolved.isEvent) {
-			return resolved as ExecutionEvent
-		}
-		
-	}
-	
-	def dispatch resolveEvent(ExecutionContext context, ElementReferenceExpression expression) {
-		val resolved = resolve(context, expression)
-		if (resolved.isEvent) {
-			return resolved as ExecutionEvent
-		}
-	}
-
-	def dispatch resolveEvent(ExecutionContext context, Expression expression) {
-		println("Unhandled expression on event slot resolution: "+expression)
-		null
-	}
-	
-	def dispatch resolveVariable(ExecutionContext context, EObject expression) {
-		println("Unhandled expression on variable slot resolution: "+expression)
-		null
-	}
 	
 	def getFqn(EObject varDef) {
 		varDef.getFullyQualifiedName
@@ -143,12 +102,4 @@ class DefaultExecutionSlotResolver implements IExecutionSlotResolver {
 	def private name(EObject e) {
 		return SimpleAttributeResolver::NAME_RESOLVER.apply(e)
 	}
-	
-	def	boolean isEvent(ExecutionSlot slot) {
-		(slot instanceof ExecutionEvent)
-	}
-	
-	def boolean isVariable(ExecutionSlot slot) {
-		!slot.isEvent
-	}
 }

plugins/org.yakindu.sct.simulation.core.sexec/src/org/yakindu/sct/simulation/core/sexec/interpreter/IExecutionSlotResolver.java

@@ -10,10 +10,8 @@
  */
 package org.yakindu.sct.simulation.core.sexec.interpreter;
 
-import org.eclipse.emf.ecore.EObject;
 import org.yakindu.base.expressions.expressions.Expression;
 import org.yakindu.sct.simulation.core.sruntime.ExecutionContext;
-import org.yakindu.sct.simulation.core.sruntime.ExecutionEvent;
 import org.yakindu.sct.simulation.core.sruntime.ExecutionSlot;
 
 import com.google.inject.ImplementedBy;
@@ -27,8 +25,13 @@ import com.google.inject.ImplementedBy;
 @ImplementedBy(DefaultExecutionSlotResolver.class)
 public interface IExecutionSlotResolver {
 	
-	// TODO use Expression instead of EObject
-	ExecutionSlot resolveVariable(ExecutionContext context, EObject expression);
-	
-	ExecutionEvent resolveEvent(ExecutionContext context, Expression expression);
+	/**
+	 * Resolves for a given {@link Expression} the corresponding {@link ExecutionSlot} within the given {@link ExecutionContext}.
+	 * 
+	 * @param context
+	 * @param expression
+	 * @return
+	 */
+	ExecutionSlot resolve(ExecutionContext context, Expression expression);
+
 }

plugins/org.yakindu.sct.simulation.core.sexec/src/org/yakindu/sct/simulation/core/sexec/interpreter/JavaOperationMockup.java

@@ -99,7 +99,7 @@ public class JavaOperationMockup implements IOperationMockup {
 	@Override
 	public boolean canExecute(FeatureCall call, Object[] parameter) {
 		ExecutionContext context = (ExecutionContext) launch.getDebugTarget().getAdapter(ExecutionContext.class);
-		ExecutionSlot variable = resolver.resolveVariable(context, call);
+		ExecutionSlot variable = resolver.resolve(context, call);
 		if (variable != null)
 			return true;
 		return false;
@@ -110,7 +110,7 @@ public class JavaOperationMockup implements IOperationMockup {
 	public Object execute(FeatureCall call, Object[] parameter) {
 		Operation operation = (Operation) call.getFeature();
 		ExecutionContext context = (ExecutionContext) launch.getDebugTarget().getAdapter(ExecutionContext.class);
-		ExecutionSlot variable = resolver.resolveVariable(context, call);
+		ExecutionSlot variable = resolver.resolve(context, call);
 		PolymorphicDispatcher<Object> dispatcher = new PolymorphicDispatcher<Object>(operation.getName(), operation
 				.getParameters().size(), operation.getParameters().size(), Collections.singletonList(variable
 				.getValue()));

plugins/org.yakindu.sct.simulation.core.sexec/src/org/yakindu/sct/simulation/core/sexec/interpreter/StextStatementInterpreter.xtend

@@ -46,6 +46,7 @@ import org.yakindu.sct.model.stext.stext.EventValueReferenceExpression
 import org.yakindu.sct.simulation.core.sruntime.ExecutionContext
 import org.yakindu.base.expressions.expressions.NullLiteral
import org.yakindu.sct.simulation.core.sruntime.ExecutionVariable
 import org.yakindu.sct.simulation.core.sruntime.CompositeSlot
+import org.yakindu.sct.simulation.core.sruntime.ExecutionEvent
 
 /**
  * 
@@ -78,7 +79,7 @@ class StextStatementInterpreter extends AbstractStatementInterpreter {
 	}
 
 	def Object executeAssignment(AssignmentExpression assignment) {
-		var scopeVariable = context.resolveVariable(assignment.varRef)
+		var scopeVariable = context.resolve(assignment.varRef)
 		var result = assignment.expression.execute
 		if (assignment.operator == AssignmentOperator::ASSIGN) {
 			scopeVariable.value = result
@@ -98,11 +99,13 @@ class StextStatementInterpreter extends AbstractStatementInterpreter {
 	}
 
 	def dispatch Object execute(EventRaisingExpression eventRaising) {
-		var event = context.resolveEvent(eventRaising.event)
+		var event = context.resolve(eventRaising.event)
 		if (eventRaising.value != null) {
 			event.value = eventRaising.value.execute
+		}
+		if (event instanceof ExecutionEvent) {
+			(event as ExecutionEvent).raised = true
 		}
-		event.raised = true
 		null
 	}
 
@@ -121,18 +124,16 @@ class StextStatementInterpreter extends AbstractStatementInterpreter {
 				return operationDelegate.execute((expression.reference as Operation), parameter.toArray)
 			}
 		}
-		var variableRef = context.resolveVariable(expression)
-		if (variableRef != null) {
-			if (variableRef instanceof ExecutionVariable)
-				return variableRef.getValue
-			// reference to an element with complex type is not reflected in an execution variable but in a composite slot
-			if (variableRef instanceof CompositeSlot)
-				return variableRef
-		}
-		val eventRef = context.resolveEvent(expression)
-		if (eventRef != null) {
-			return eventRef.raised
-		}
+		val executionSlot = context.resolve(expression)
+		if (executionSlot instanceof ExecutionVariable)
+			return executionSlot.getValue
+		if (executionSlot instanceof ExecutionEvent)
+			return (executionSlot as ExecutionEvent).raised
+		// reference to an element with complex type is not reflected in an execution variable but in a composite slot
+		// TODO hide reference mechanism in resolver
+		if (executionSlot instanceof CompositeSlot)
+			return executionSlot
+			
 		return null
 	}
 
@@ -234,13 +235,13 @@ class StextStatementInterpreter extends AbstractStatementInterpreter {
 		} else if (call.getFeature() instanceof Enumerator) {
 			return call.getFeature();
 		} else {
-			var variableRef = context.resolveVariable(call)
-			if (variableRef != null) {
+			var variableRef = context.resolve(call)
+			if (variableRef instanceof ExecutionVariable || variableRef instanceof CompositeSlot) {
 				return variableRef.getValue
 			}
-			var event = context.resolveEvent(call)
-			if (event != null)
-				return event.raised
+			if (variableRef instanceof ExecutionEvent)
+				return (variableRef as ExecutionEvent).raised
+				
 			println("No feature found for " + call.feature.fqn + " -> returning null")
 			return null;
 		}