Composite start graph refactored so as to enable better error reporting

Author: rensink

src/main/java/nl/utwente/groove/grammar/model/CompositeHostModel.java

@@ -2,29 +2,48 @@
 
 import static nl.utwente.groove.grammar.model.ResourceKind.HOST;
 import static nl.utwente.groove.grammar.model.ResourceKind.PROPERTIES;
-import static nl.utwente.groove.grammar.model.ResourceKind.TYPE;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
 
-import nl.utwente.groove.grammar.QualName;
 import nl.utwente.groove.grammar.aspect.AspectGraph;
 import nl.utwente.groove.grammar.host.HostGraph;
-import nl.utwente.groove.util.parse.FormatError;
+import nl.utwente.groove.grammar.type.TypeLabel;
+import nl.utwente.groove.util.Factory;
 import nl.utwente.groove.util.parse.FormatErrorSet;
 import nl.utwente.groove.util.parse.FormatException;
 
-/** Class to store the models that are used to compose the type graph. */
+/** Class compute the composed start graph. */
+@NonNullByDefault
 public class CompositeHostModel extends ResourceModel<HostGraph> {
     /**
      * Constructs a composite type model
      * @param grammar the underlying graph grammar
      */
-    CompositeHostModel(@NonNull GrammarModel grammar) {
-        super(grammar, TYPE);
+    CompositeHostModel(GrammarModel grammar) {
+        this(grammar, null);
+    }
+
+    /**
+     * Constructs a composite type model from a single aspect graph.
+     * @param grammar the underlying graph grammar
+     * @param source the explicit source aspect graph; if {@code null}, the source
+     * is implicit and derived from the active host graphs of the grammar.
+     */
+    CompositeHostModel(GrammarModel grammar, @Nullable AspectGraph source) {
+        super(grammar, HOST);
         setDependencies(PROPERTIES);
+        this.implicit = source == null;
+        this.hostModels = this.implicit
+            ? null // to be initialised later
+            : Collections.<HostModel>singletonList(new HostModel(grammar, source));
     }
 
     @Override
@@ -34,52 +53,144 @@ public class CompositeHostModel extends ResourceModel<HostGraph> {
         return result;
     }
 
+    /** Indicates if this composite model is implicit, i.e., derived from the active host graphs
+     * in the grammar.
+     */
+    public boolean isImplicit() {
+        return this.implicit;
+    }
+
+    private final boolean implicit;
+
     @Override
-    public Object getSource() {
-        return null;
+    public @Nullable AspectGraph getSource() {
+        return this.source.get();
     }
 
+    /** The (lazily created) source aspect graph. */
+    private final Factory<@Nullable AspectGraph> source = Factory.lazy(() -> {
+        AspectGraph result = null;
+        var hostModels = getHostModels();
+        if (hostModels.size() == 1) {
+            result = hostModels.getFirst().getSource();
+        } else if (hostModels.size() > 1) {
+            result = AspectGraph.mergeGraphs(getGrammar().getActiveGraphs(HOST));
+        }
+        return result;
+    });
+
+    /** Returns the set of type labels in the combined source graphs. */
+    public Set<TypeLabel> getTypeLabels() {
+        return this.typeLabels.get();
+    }
+
+    /**
+     * Returns a mapping from the nodes in the model source to the corresponding
+     * nodes in the resource that is constructed from it.
+     * This method should only be called if the model contains no errors.
+     * @return the mapping from source graph to resource elements
+     */
+    public HostModelMap getMap() {
+        var model = getCombinedModel();
+        assert model != null;
+        return model.getMap();
+    }
+
+    private final Factory<Set<TypeLabel>> typeLabels = Factory.lazy(() -> {
+        var result = new HashSet<TypeLabel>();
+        for (var model : getHostModels()) {
+            result.addAll(model.getTypeLabels());
+        }
+        return result;
+    });
+
     @Override
     public String getName() {
-        return "Composite host graph";
+        var source = getSource();
+        return source == null
+            ? ""
+            : source.getName();
     }
 
-    /** Indicates if this model is composed of more than one underlying host model. */
-    public boolean isMultiple() {
-        return getGrammar().getActiveNames(HOST).size() > 1;
+    @Override
+    void notifyWillRebuild() {
+        super.notifyWillRebuild();
+        if (isImplicit()) {
+            this.hostModels = null;
+            this.combinedModel.reset();
+            this.source.reset();
+            this.typeLabels.reset();
+        }
     }
 
     @Override
     HostGraph compute() throws FormatException {
-        var hostModelMap = computeHostModelMap();
-        if (hostModelMap.isEmpty()) {
+        HostGraph result = null;
+        var hostModels = getHostModels();
+        FormatErrorSet errors = new FormatErrorSet();
+        for (var model : hostModels) {
+            for (var error : model.getErrors()) {
+                errors.add("Error in graph '%s': %s", model.getName(), error, model.getSource());
+            }
+        }
+        errors.throwException();
+        var combinedModel = getCombinedModel();
+        if (combinedModel == null) {
             throw new FormatException("No active start graph");
         } else {
-            AspectGraph startGraph = AspectGraph.mergeGraphs(getGrammar().getActiveGraphs(HOST));
-            return new HostModel(getGrammar(), startGraph).compute();
+            try {
+                result = combinedModel.toHost();
+            } catch (FormatException exc) {
+                for (var error : exc.getErrors()) {
+                    errors.add("Error in composite host graph: %s", error);
+                }
+                errors.throwException();
+            }
         }
+        assert result != null;
+        return result;
     }
 
+    /** Returns the combined host model.
+     * This is either {@code null} of there is no active host model, or the singular host model, or a new
+     * host model obtained from the merged sources of the active host models, if there are multiple.
+     */
+    private @Nullable HostModel getCombinedModel() {
+        return this.combinedModel.get();
+    }
+
+    /** The combined host model.
+     * @see #getCombinedModel()
+     */
+    private final Factory<@Nullable HostModel> combinedModel = Factory.lazy(() -> {
+        HostModel result = null;
+        var hostModels = getHostModels();
+        if (hostModels.size() == 1) {
+            result = hostModels.getFirst();
+        } else {
+            result = new HostModel(getGrammar(), getSource());
+
+        }
+        return result;
+    });
+
     /**
-     * Computes the mapping from names to active host models.
-     * @throws FormatException if there are format errors in the active type models
+     * Returns the list of active host models.
      */
-    private Map<QualName,HostModel> computeHostModelMap() throws FormatException {
-        FormatErrorSet errors = new FormatErrorSet();
-        Map<QualName,HostModel> result = new HashMap<>();
-        for (var activeHostName : getGrammar().getActiveNames(HOST)) {
-            ResourceModel<?> hostModel = getGrammar().getResource(HOST, activeHostName);
-            result.put(activeHostName, (HostModel) hostModel);
-            for (FormatError error : hostModel.getErrors()) {
-                errors
-                    .add("Error in host graph '%s': %s", activeHostName, error,
-                         hostModel.getSource());
+    private List<HostModel> getHostModels() {
+        var result = this.hostModels;
+        if (result == null) {
+            result = new ArrayList<>();
+            for (var name : getGrammar().getActiveNames(HOST)) {
+                var model = getGrammar().getResource(HOST, name);
+                result.add((HostModel) model);
             }
         }
-        errors.throwException();
         return result;
     }
 
+    private @Nullable List<HostModel> hostModels;
+
     /** Fixed name for the composite host model. */
     static public final String NAME = "composite-host";
 }

src/main/java/nl/utwente/groove/grammar/model/CompositeTypeModel.java

@@ -5,9 +5,11 @@
 import static nl.utwente.groove.grammar.model.ResourceKind.RULE;
 import static nl.utwente.groove.grammar.model.ResourceKind.TYPE;
 
+import java.util.ArrayList;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
@@ -118,20 +120,20 @@ boolean isShouldRebuild() {
     @Override
     TypeGraph compute() throws FormatException {
         TypeGraph result = null;
-        Map<QualName,TypeModel> typeModelMap = computeTypeModelMap();
+        var typeModels = computeTypeModels();
         // first test if there is something to be done
-        if (typeModelMap.isEmpty()) {
+        if (typeModels.isEmpty()) {
             result = getImplicitTypeGraph();
-        } else if (typeModelMap.size() == 1) {
-            result = typeModelMap.values().iterator().next().toResource();
+        } else if (typeModels.size() == 1) {
+            result = typeModels.iterator().next().toResource();
         } else {
             result = new TypeGraph(QualName.name(NAME));
             FormatErrorSet errors = createErrors();
             // There are no errors in each of the models, try to compose the
             // type graph.
             Map<TypeNode,TypeNode> nodeMergeMap = new HashMap<>();
             Map<TypeNode,TypeModel> importModels = new HashMap<>();
-            for (TypeModel model : typeModelMap.values()) {
+            for (TypeModel model : typeModels) {
                 try {
                     TypeGraph graph = model.toResource();
                     nodeMergeMap.putAll(result.add(graph));
@@ -176,18 +178,18 @@ TypeGraph compute() throws FormatException {
      * Computes the mapping from names to active type models.
      * @throws FormatException if there are format errors in the active type models
      */
-    private Map<QualName,TypeModel> computeTypeModelMap() throws FormatException {
+    private List<TypeModel> computeTypeModels() throws FormatException {
         FormatErrorSet errors = new FormatErrorSet();
-        Map<QualName,TypeModel> typeModelMap = new HashMap<>();
+        var result = new ArrayList<TypeModel>();
         for (QualName activeTypeName : getGrammar().getActiveNames(TYPE)) {
             ResourceModel<?> typeModel = getGrammar().getResource(TYPE, activeTypeName);
-            typeModelMap.put(activeTypeName, (TypeModel) typeModel);
+            result.add((TypeModel) typeModel);
             for (FormatError error : typeModel.getErrors()) {
                 errors.add("Error in type '%s': %s", activeTypeName, error, typeModel.getSource());
             }
         }
         errors.throwException();
-        return typeModelMap;
+        return result;
     }
 
     /**
@@ -199,30 +201,30 @@ private TypeGraph getImplicitTypeGraph() {
 
     /** The implicit type graph. */
     private final Factory<TypeGraph> implicitTypeGraph
-        = Factory.lazy(() -> ImplicitTypeGraph.newInstance(getLabels()));
+        = Factory.lazy(() -> ImplicitTypeGraph.newInstance(getTypeLabels()));
 
     @Override
     void notifyWillRebuild() {
         this.implicitTypeGraph.reset();
     }
 
     /**
-     * Computes the set of all labels occurring in the rules and host graph.
+     * Computes the set of all type labels occurring in the rules and host graph.
      * This is used to construct the implicit type graph,
      * if no type graphs are enabled.
      */
-    private Set<TypeLabel> getLabels() {
+    private Set<TypeLabel> getTypeLabels() {
         Set<TypeLabel> result = new HashSet<>();
         // get the labels from the rules and host graphs
         for (ResourceKind kind : EnumSet.of(RULE, HOST)) {
             for (ResourceModel<?> model : getGrammar().getResourceSet(kind)) {
-                result.addAll(((GraphBasedModel<?>) model).getLabels());
+                result.addAll(((GraphBasedModel<?>) model).getTypeLabels());
             }
         }
         // get the labels from the external start graph
-        HostModel host = getGrammar().getStartGraphModel();
+        var host = getGrammar().getStartGraphModel();
         if (host != null) {
-            result.addAll(host.getLabels());
+            result.addAll(host.getTypeLabels());
         }
         return result;
     }