[Type Checker] Refactor duplicated code

Because:
 - duplicated code makes changes hard

How:
 - introduce a new TypeChecker class responsible of checking compatibility between types
 - refactor some methods of TypeValidator to remove duplicated code

Also improve the type checker to:
 - check type of variables when using the '+=' and '-=' operators
 - check type variables declared within for each loops
 - check types when assigning a value to `result` (:=, += and -= operators)

Also improve the AST builder to:
 - retrieve missing generic type parameters

Signed-off-by: Emmanuel Chebbi <emmanuel.chebbi@outlook.fr>

Author: echebbi

plugins/org.eclipse.emf.ecoretools.ale.core/src/org/eclipse/emf/ecoretools/ale/core/parser/visitor/ModelBuilder.java

@@ -19,6 +19,7 @@
 import org.antlr.v4.runtime.misc.Interval;
 import org.eclipse.acceleo.query.ast.AstFactory;
 import org.eclipse.acceleo.query.ast.Binding;
+import org.eclipse.acceleo.query.ast.CollectionTypeLiteral;
 import org.eclipse.acceleo.query.ast.Expression;
 import org.eclipse.acceleo.query.ast.IntegerLiteral;
 import org.eclipse.acceleo.query.ast.Let;
@@ -151,7 +152,10 @@ public Method buildMethod(EClass fragment, String name, List<Parameter> params,
 		});
 
 		EClassifier type = resolve(returnType);
-		operation.setEType(type);
+		operation.setEType(type); // also set EGenericType
+		resolveGenericTypeParameter(type, returnType.getText())
+			.ifPresent(t -> operation.getEGenericType().getETypeArguments().add(t));
+
 		fragment.getEOperations().add(operation);
 
 		return buildMethod(operation,body,tags);
@@ -197,7 +201,10 @@ public Attribute buildAttribute(EClass fragment, String name, RExpressionContext
 		}
 
 		feature.setName(name);
-		feature.setEType(featureType);
+		feature.setEType(featureType); // also set EGenericType
+		resolveGenericTypeParameter(featureType, type.getText())
+			.ifPresent(t -> feature.getEGenericType().getETypeArguments().add(t));
+
 		attribute.setFeatureRef(feature);
 
 		if(exp != null){
@@ -232,6 +239,7 @@ public VariableDeclaration buildVariableDecl(String name, RExpressionContext exp
 		if(declaredType == EcorePackage.eINSTANCE.getEEList()) {
 			EClassifier parameterType = resolveParameterType(type);
 			varDecl.setTypeParameter(parameterType);
+			// FIXME add generic type
 		}
 
 		return varDecl;
@@ -558,6 +566,7 @@ else if(result instanceof EClassifier) {
 		return resolve(type.getText()); //default
 	}
 
+	// TODO [Refactor] Can this method be made private safely?
 	public EClassifier resolveParameterType(RTypeContext type) {
 		AstResult astResult = builder.build(type.getText());
 		if(astResult.getAst() instanceof CollectionTypeLiteralImpl ) {
@@ -585,6 +594,36 @@ else if(paramType instanceof EClassifier) {
 
 		return null;
 	}
+	
+	private Optional<EGenericType> resolveGenericTypeParameter(EClassifier type, String code) {
+		if (type != null && EList.class.equals(type.getInstanceClass())) {
+			AstResult ast = builder.build(code);
+			if (ast.getAst() instanceof CollectionTypeLiteral) {
+				CollectionTypeLiteral collectionTypeLiteral = (CollectionTypeLiteral) ast.getAst();
+				
+				EClassifier classifier;
+				
+				if (collectionTypeLiteral.getElementType().getValue() instanceof Class<?>) {
+					classifier = EcoreFactory.eINSTANCE.createEDataType();
+					classifier.setInstanceClass((Class<?>) collectionTypeLiteral.getElementType().getValue());
+					classifier.setName(classifier.getInstanceClass().getSimpleName());
+					classifier.setInstanceTypeName(classifier.getInstanceClass().getName());
+					classifier.setInstanceClassName(classifier.getInstanceClass().getName());
+				}
+				else if (collectionTypeLiteral.getElementType().getValue() instanceof EClass) {
+					classifier = (EClass) collectionTypeLiteral.getElementType().getValue();
+				}
+				else {
+					classifier = null;
+				}
+				EGenericType generic = EcoreFactory.eINSTANCE.createEGenericType();
+				generic.setEClassifier(classifier);
+				
+				return Optional.of(generic);
+			}
+		}
+		return Optional.empty();
+	}
 
 
 	public static String getQualifiedName(EClassifier cls) {

plugins/org.eclipse.emf.ecoretools.ale.core/src/org/eclipse/emf/ecoretools/ale/core/parser/visitor/ParseResult.java

@@ -37,6 +37,7 @@ public Map<Object, Integer> getStartPositions() {
 	}
 
 	public Map<Object, Integer> getEndPositions() {
+		// FIXME It looks like some end position are missing the last character in source code
 		return endPositions;
 	}
 

plugins/org.eclipse.emf.ecoretools.ale.core/src/org/eclipse/emf/ecoretools/ale/core/validation/BaseValidator.java

@@ -62,6 +62,9 @@
 
 import com.google.common.collect.Sets;
 
+/**
+ * Visits an ALE program's AST delegating validation of each element to given {@link IValidator validators}. 
+ */
 public class BaseValidator extends ImplementationSwitch<Object> {
 
 	List<IValidationMessage> msgs;

plugins/org.eclipse.emf.ecoretools.ale.core/src/org/eclipse/emf/ecoretools/ale/core/validation/IAstLookup.java

@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Inria and Obeo.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Inria - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.emf.ecoretools.ale.core.validation;
+
+import java.util.Set;
+
+import org.eclipse.acceleo.query.ast.Expression;
+import org.eclipse.acceleo.query.validation.type.IType;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecoretools.ale.implementation.Method;
+import org.eclipse.emf.ecoretools.ale.implementation.Statement;
+
+/**
+ * Used to retrieve the types of expressions manipulated by ALE.
+ */
+public interface IAstLookup {
+	
+	/**
+	 * Infers the types of a given expression.
+	 * 
+	 * @param expression
+	 * 			The expression which types must be inferred
+	 * 
+	 * @return the types inferred for the given expression
+	 */
+	Set<IType> inferredTypesOf(Expression expression);
+	
+	/**
+	 * Determines the types used to declare a variable.
+	 * 
+	 * @param variableName
+	 * 			The name of the variable to check
+	 * @param astBranch
+	 * 			A branch of the AST from which types will be looked for
+	 * 
+	 * @return the types found for the given variable
+	 */
+	Set<IType> typesDeclaredFor(String variableName, EObject astBranch);
+	
+	/**
+	 * Determines all the possible types of a feature.
+	 * 
+	 * @param featureName
+	 * 			The name of the feature
+	 * @param featureAccessExpression
+	 * 			The expression representing the access to the feature
+	 * 
+	 * @return all the possible types of the feature
+	 */
+	Set<IType> findFeatureTypes(String featureName, Expression featureAccessExpression);
+	
+	/**
+	 * Determines the method that surrounds a statement.
+	 * 
+	 * @param statement
+	 * 			The statement to check
+	 * 
+	 * @return the method enclosing the given statement
+	 */
+	// TODO [Refactor] Consider returning Optional<Method>
+	Method enclosingMethod(Statement statement);
+	
+}

plugins/org.eclipse.emf.ecoretools.ale.core/src/org/eclipse/emf/ecoretools/ale/core/validation/IConvertType.java

@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Inria and Obeo.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Inria - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.emf.ecoretools.ale.core.validation;
+
+import java.util.Optional;
+
+import org.eclipse.acceleo.query.validation.type.IType;
+import org.eclipse.acceleo.query.validation.type.NothingType;
+import org.eclipse.acceleo.query.validation.type.SequenceType;
+import org.eclipse.acceleo.query.validation.type.SetType;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.ETypedElement;
+import org.eclipse.emf.ecore.EcorePackage;
+
+/**
+ * Performs conversions between AQL's {@link IType} and EMF's {@link EClassifier}.
+ */
+public interface IConvertType {
+	
+	/**
+	 * Turns an EMF typed element into an AQL type.
+	 * <p>
+	 * <h3>Type matching</h3>
+	 * <ul>
+	 * 	<li>{@link EcorePackage#getEEList() EEList} are turned into {@link SequenceType},
+	 * 	<li>{@link EStructuralFeature} with multiplicity "many" are turned into {@link SequenceType}, 
+	 * 	<li>{@link EStructuralFeature} with multiplicity "one" are turned into {@link SetType},
+	 * </ul>
+	 * For others, return {@link #toAQL(EClassifier) toAQL(typedElement.getEType())}.
+	 * <p>
+	 * <h3>Genericity</h3>
+	 * 
+	 * If the new type should have a generic parameter type but it cannot be resolved, 
+	 * {@link NothingType NothingType("?")} is used instead.
+	 * 
+	 * @param typedElement
+	 * 			The EMF element to convert to AQL
+	 * 
+	 * @return the AQL type corresponding to the given EMF type
+	 */
+	IType toAQL(ETypedElement typedElement);
+	
+	/**
+	 * Turns an EMF classifier into an AQL type.
+	 * <p>
+	 * If the classifier is turned into a generic type, such as {@link SequenceType},
+	 * its generic type parameter won't be resolved. For this reason you should use 
+	 * {@link #toAQL(EClassifier, EClassifier)} whenever possible.
+	 * 
+	 * @param type
+	 * 			The EMF classifier to convert
+	 * 
+	 * @return the AQL type corresponding to the given EMF classifier
+	 * 
+	 * @see #toAQL(EClassifier, EClassifier)
+	 */
+	IType toAQL(EClassifier type);
+	
+	/**
+	 * Turns an EMF classifier into an AQL type.
+	 * 
+	 * @param type
+	 * 			The EMF classifier to convert
+	 * @param typeParameter
+	 * 			The EMF generic type parameter or null if the type is not generic
+	 * 
+	 * @return the AQL type corresponding to the given EMF classifier
+	 * 
+	 * @see #toAQL(EClassifier)
+	 */
+	IType toAQL(EClassifier type, EClassifier typeParameter);
+
+	/**
+	 * Attempts to turn an AQL type into an EMF classifier.
+	 * 
+	 * @param type
+	 * 			The AQL type to convert
+	 * 
+	 * @return the EMF classifier corresponding to the given AQL type
+	 * 		   if able to convert it
+	 */
+	Optional<EClassifier> toEMF(IType type);
+	
+}