[ST6RI-881] Refactored computation and caching of types of a Feature.

- Ensured that implicit types are computed when the types are derived.

Author: seidewitz

kerml/src/examples/Simple Tests/MetadataTest.kerml

@@ -38,4 +38,18 @@ package MetadataTest {
 	    }
 	}
 
+    class CC;
+    struct SS {
+        feature cc : CC;
+    }
+    
+    metaclass M :> Metaobjects::SemanticMetadata {
+      :>> annotatedElement : KerML::Class;
+      :>> baseType = if annotatedElement istype KerML::Structure ? 
+                         SS meta KerML::Type else CC meta KerML::Class;
+    }
+    
+    #M struct T {
+        feature :>> cc;
+    }
 }

org.omg.sysml/src/org/omg/sysml/adapter/FeatureAdapter.java

@@ -34,6 +34,7 @@
 
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
 import org.omg.sysml.lang.sysml.Association;
 import org.omg.sysml.lang.sysml.BindingConnector;
 import org.omg.sysml.lang.sysml.Connector;
@@ -61,6 +62,7 @@
 import org.omg.sysml.util.ElementUtil;
 import org.omg.sysml.util.ExpressionUtil;
 import org.omg.sysml.util.FeatureUtil;
+import org.omg.sysml.util.NonNotifyingEObjectEList;
 import org.omg.sysml.util.TypeUtil;
 
 public class FeatureAdapter extends TypeAdapter {
@@ -112,15 +114,6 @@ public String getEffectiveShortName() {
 		return storedEffectiveShortName;
 	}
 
-	public EList<Type> getTypes() {
-		return types;
-	}
-	
-	public EList<Type> setTypes(EList<Type> types) {
-		this.types = types;
-		return types;
-	}
-	
 	Set<Feature> allRedefinedFeatures = null;
 
 	@Override
@@ -549,6 +542,45 @@ public boolean isComputeRedefinitions() {
 				  target.getOwnedRedefinition().isEmpty());
 	}
 
+	public EList<Type> getAllTypes() {
+		if (types == null) {
+			types = new NonNotifyingEObjectEList<Type>(Type.class, (InternalEObject)getTarget(), SysMLPackage.FEATURE__TYPE);
+			getTypes(types, new HashSet<Feature>());
+			removeRedundantTypes(types);
+		}
+		return types;
+	}
+	
+	public void getTypes(List<Type> types, Set<Feature> visitedFeatures) {
+		Feature feature = getTarget();
+		visitedFeatures.add(feature);
+		computeImplicitGeneralTypes();
+		getFeatureTypes(types, visitedFeatures);
+		for (Feature typingFeature : feature.typingFeatures()) {
+			if (!visitedFeatures.contains(typingFeature)) {
+				FeatureUtil.getTypesOf(typingFeature, types, visitedFeatures);
+			}
+		}
+	}
+	
+	public void getFeatureTypes(List<Type> types, Set<Feature> visitedFeatures) {
+		Feature feature = getTarget();
+		feature.getOwnedTyping().stream().
+				map(typing->typing.getType()).
+				filter(type->type != null).
+				forEachOrdered(types::add);
+		types.addAll(getImplicitGeneralTypes(SysMLPackage.eINSTANCE.getFeatureTyping()));
+	}
+	
+	protected static void removeRedundantTypes(List<Type> types) {
+		for (int i = types.size() - 1; i >= 0 ; i--) {
+			Type type = types.get(i);
+			if (types.stream().anyMatch(otherType->otherType != type && TypeUtil.specializes(otherType, type))) {
+				types.remove(i);
+			}
+		}
+	}
+		
 	/**
 	 * Compute relevant implicit Redefinitions, as appropriate.
 	 */

org.omg.sysml/src/org/omg/sysml/util/FeatureUtil.java

@@ -29,7 +29,6 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
-import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -58,7 +57,6 @@
 import org.omg.sysml.lang.sysml.Step;
 import org.omg.sysml.lang.sysml.Subsetting;
 import org.omg.sysml.lang.sysml.SysMLFactory;
-import org.omg.sysml.lang.sysml.SysMLPackage;
 import org.omg.sysml.lang.sysml.Type;
 import org.omg.sysml.lang.sysml.TypeFeaturing;
 
@@ -120,12 +118,6 @@ public static boolean checkIsOrdered(Feature feature, Set<Feature> visited) {
 
 	// Typing
 
-	public static EList<Type> cacheTypesOf(Feature feature, Supplier<EList<Type>> supplier) {	
-		FeatureAdapter adapter = getFeatureAdapter(feature);
-		EList<Type> types = adapter.getTypes();
-		return types == null? adapter.setTypes(supplier.get()): types;
-	}
-	
 	public static <T> T getFirstTypeOf(Feature feature, Class<T> kind) {
 		return FeatureUtil.getAllTypesOf(feature).stream().
 				filter(kind::isInstance).
@@ -144,39 +136,11 @@ public static <T> EList<T> getAllTypesOf(Feature feature, Class<T> kind, int fea
 	}
 
 	public static EList<Type> getAllTypesOf(Feature feature) {
-		return FeatureUtil.cacheTypesOf(feature, ()->{
-			EList<Type> types = new NonNotifyingEObjectEList<Type>(Type.class, (InternalEObject)feature, SysMLPackage.FEATURE__TYPE);
-			getTypesOf(feature, types, new HashSet<Feature>());
-			removeRedundantTypes(types);
-			return types;
-		});
+		return getFeatureAdapter(feature).getAllTypes();
 	}
 
-	private static void getTypesOf(Feature feature, List<Type> types, Set<Feature> visitedFeatures) {
-		visitedFeatures.add(feature);
-		getFeatureTypesOf(feature, types, visitedFeatures);
-		for (Feature typingFeature : feature.typingFeatures()) {
-			if (!visitedFeatures.contains(typingFeature)) {
-				getTypesOf(typingFeature, types, visitedFeatures);
-			}
-		}
-	}
-	
-	private static void getFeatureTypesOf(Feature feature, List<Type> types, Set<Feature> visitedFeatures) {
-		feature.getOwnedTyping().stream().
-				map(typing->typing.getType()).
-				filter(type->type != null).
-				forEachOrdered(types::add);
-		types.addAll(TypeUtil.getImplicitGeneralTypesFor(feature, SysMLPackage.eINSTANCE.getFeatureTyping()));
-	}
-	
-	protected static void removeRedundantTypes(List<Type> types) {
-		for (int i = types.size() - 1; i >= 0 ; i--) {
-			Type type = types.get(i);
-			if (types.stream().anyMatch(otherType->otherType != type && TypeUtil.specializes(otherType, type))) {
-				types.remove(i);
-			}
-		}
+	public static void getTypesOf(Feature feature, List<Type> types, Set<Feature> visitedFeatures) {
+		getFeatureAdapter(feature).getTypes(types, visitedFeatures);
 	}
 
 	public static FeatureTyping addFeatureTypingTo(Feature feature) {