[463430] FeatureInterpreter returns possible result types

Bug: 463430
Change-Id: Ib86095b1d094965dfdddc227d1d16d688d5ddaeb
Signed-off-by: Cedric Brun <cedric.brun@obeo.fr>

2 files changed, 33 insertions, 4 deletions

diff --git a/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/api/interpreter/VariableType.java b/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/api/interpreter/VariableType.java
index 092b352a36..d0c6686e5b 100644
--- a/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/api/interpreter/VariableType.java
+++ b/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/api/interpreter/VariableType.java
@@ -16,6 +16,7 @@ import java.util.List;
 import java.util.Set;
 
 import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EPackage;
 
 import com.google.common.base.Joiner;
@@ -74,6 +75,21 @@ public final class VariableType {
     }
 
     /**
+     * Create a new {@link VariableType} from a collection of EClassifiers.
+     * 
+     * @param types
+     *            a collection of EClassifiers
+     * @return the newly created instance.
+     */
+    public static VariableType fromEClassifiers(Collection<EClassifier> types) {
+        VariableType result = new VariableType();
+        for (EClassifier domainClass : types) {
+            result.types.add(TypeName.fromEClassifier(domainClass));
+        }
+        return result;
+    }
+
+    /**
      * Return a {@link TypeName} representation of a common type matching all
      * the definitions. This should only be used by interpreters or code which
      * can't take into account the fact that a Variable can have multiple types
diff --git a/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/internal/interpreter/FeatureInterpreter.java b/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/internal/interpreter/FeatureInterpreter.java
index 92b2438bcb..ac42a702a1 100644
--- a/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/internal/interpreter/FeatureInterpreter.java
+++ b/plugins/org.eclipse.sirius.common/src/org/eclipse/sirius/common/tools/internal/interpreter/FeatureInterpreter.java
@@ -11,9 +11,12 @@
 package org.eclipse.sirius.common.tools.internal.interpreter;
 
 import java.util.Iterator;
+import java.util.Set;
 
 import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.sirius.common.tools.api.interpreter.EvaluationException;
 import org.eclipse.sirius.common.tools.api.interpreter.IInterpreter;
@@ -27,6 +30,7 @@ import org.eclipse.sirius.common.tools.api.interpreter.VariableType;
 
 import com.google.common.collect.Iterators;
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 
 /**
  * A specialized interpreter which only supports direct access to a named
@@ -116,26 +120,35 @@ public class FeatureInterpreter extends AbstractInterpreter implements org.eclip
             String featureName = expression.substring(PREFIX.length());
             VariableType targetType = context.getTargetType();
             if (!isDefaultFeatureName(featureName)) {
+                Set<EClassifier> possibleReturnTypes = Sets.newLinkedHashSet();
                 for (TypeName typeName : targetType.getPossibleTypes()) {
                     Iterator<EClass> possibleEClasses = Iterators.filter(typeName.search(context.getAvailableEPackages()).iterator(), EClass.class);
                     boolean foundAtLeastOneValid = false;
                     while (!foundAtLeastOneValid && possibleEClasses.hasNext()) {
                         EClass cur = possibleEClasses.next();
-                        foundAtLeastOneValid = hasFeatureName(cur, featureName);
+                        foundAtLeastOneValid = hasFeatureNameAndCollectReturnTypes(cur, featureName, possibleReturnTypes);
                     }
                     if (!foundAtLeastOneValid) {
                         interpreterStatus.addStatus(InterpreterStatusFactory.createInterpreterStatus(context, IInterpreterStatus.ERROR, "The current element " + typeName.getCompleteName("::")
                                 + " does not have the feature named : " + featureName));
                     }
                 }
+                if (possibleReturnTypes.size() > 0) {
+                    interpreterStatus.setReturnType(VariableType.fromEClassifiers(possibleReturnTypes));
+                }
             }
         }
         return interpreterStatus;
     }
 
-    private boolean hasFeatureName(EClass currentElementType, String featureName) {
-        boolean hasFeatureName = currentElementType.getEStructuralFeature(featureName) != null;
-        return hasFeatureName;
+    private boolean hasFeatureNameAndCollectReturnTypes(EClass currentElementType, String featureName, Set<EClassifier> possibleTargetTypes) {
+        EStructuralFeature feature = currentElementType.getEStructuralFeature(featureName);
+        if (feature instanceof EReference) {
+            if (feature.getEType() != null) {
+                possibleTargetTypes.add(feature.getEType());
+            }
+        }
+        return feature != null;
     }
 
     private boolean isDefaultFeatureName(String featureName) {