fix: tolerate an unresolvable grammar in export model generation

The sibling-grammar lookup in ExportGeneratorX.getGrammar demand-loads
<name>.xtext next to the export model; for models with no such sibling
(every test .export file, models built via ParseHelper) the load throws
and the builder participant logs "Error during compilation" and silently
aborts generation for the file — dozens of ERROR entries in every full
test run, and the generator's main path never executes over the test
fixtures.

Make grammar resolution defensive: guard a missing resource or resource
set, reject unresolved targetGrammar proxies, and catch the demand-load
failure, returning null. Downstream, GeneratorUtil.allInstantiatedTypes
treats a null grammar as "no parser-instantiated subtypes" (covering
typeMap and canContain), and the remaining generator call sites already
tolerate a null grammar (grammar?.name in ExportedNamesProviderGenerator;
an explicit null check in ResourceDescriptionManagerGenerator). Export
model generation now degrades gracefully instead of aborting.

Phase 0 of #1458.

Author: joaodinissf

com.avaloq.tools.ddk.xtext.export.test/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGeneratorXTest.java

@@ -11,10 +11,15 @@
 package com.avaloq.tools.ddk.xtext.export.generator;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.xtext.Grammar;
+import org.eclipse.xtext.XtextFactory;
 import org.junit.jupiter.api.Test;
 
 import com.avaloq.tools.ddk.xtext.export.export.ExportFactory;
@@ -32,6 +37,7 @@ public class ExportGeneratorXTest extends AbstractXtextTest {
   private static final String DERIVED_PACKAGE_PROVIDER = "com.avaloq.naming.fooExportedNamesProvider";
   private static final String PROJECT_FALLBACK_PROVIDER = "MyProject.naming.fooExportedNamesProvider";
   private static final String DEFAULT_FALLBACK_PROVIDER = "generated.naming.fooExportedNamesProvider";
+  private static final String NO_SIBLING_URI = "platform:/resource/TEST/NoSibling.export";
 
   private final ExportGeneratorX exportGeneratorX = getXtextTestUtil().get(ExportGeneratorX.class);
 
@@ -71,6 +77,26 @@ public void testSingleSegmentUriFallsBackToDefaultPackage() {
     assertEquals(DEFAULT_FALLBACK_PROVIDER, exportedNamesProviderFor("foo.export"));
   }
 
+  @Test
+  public void testGetGrammarReturnsNullWithoutResolvableGrammar() {
+    final ExportModel detached = ExportFactory.eINSTANCE.createExportModel();
+    assertNull(exportGeneratorX.getGrammar(detached), "model without a resource");
+
+    final ExportModel withoutResourceSet = ExportFactory.eINSTANCE.createExportModel();
+    new ResourceImpl(URI.createURI(NO_SIBLING_URI)).getContents().add(withoutResourceSet);
+    assertNull(exportGeneratorX.getGrammar(withoutResourceSet), "resource without a resource set");
+
+    final ExportModel withoutSibling = ExportFactory.eINSTANCE.createExportModel();
+    final Resource resource = new ResourceSetImpl().createResource(URI.createURI(NO_SIBLING_URI));
+    resource.getContents().add(withoutSibling);
+    assertNull(exportGeneratorX.getGrammar(withoutSibling), "missing sibling grammar must not throw");
+
+    final Grammar proxy = XtextFactory.eINSTANCE.createGrammar();
+    ((InternalEObject) proxy).eSetProxyURI(URI.createURI("platform:/resource/TEST/Unresolved.xtext#/"));
+    withoutSibling.setTargetGrammar(proxy);
+    assertNull(exportGeneratorX.getGrammar(withoutSibling), "unresolved targetGrammar proxy");
+  }
+
   private String exportedNamesProviderFor(final String uri) {
     final Resource resource = new ResourceImpl(URI.createURI(uri));
     final ExportModel model = ExportFactory.eINSTANCE.createExportModel();

com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGeneratorX.xtend

@@ -47,13 +47,22 @@ class ExportGeneratorX {
   }
 
   def Grammar getGrammar(ExportModel model) {
-    val uri = model.eResource.URI
     // Grammar should be set correctly for export extensions, not yet for normal export sources
-    if(model.targetGrammar !== null) {
+    if (model.targetGrammar !== null && !model.targetGrammar.eIsProxy) {
       return model.targetGrammar;
     }
-    val grammarResource = model.eResource.resourceSet.getResource(uri.trimSegments(1).appendSegment(uri.trimFileExtension.lastSegment + '.xtext'), true)
-    return grammarResource?.contents.head as Grammar
+    val resource = model.eResource
+    if (resource?.resourceSet === null) {
+      return null
+    }
+    val uri = resource.URI
+    try {
+      val grammarResource = resource.resourceSet.getResource(uri.trimSegments(1).appendSegment(uri.trimFileExtension.lastSegment + '.xtext'), true)
+      return grammarResource?.contents.head as Grammar
+    } catch (RuntimeException e) {
+      // no resolvable sibling grammar; all generators tolerate a null grammar
+      return null
+    }
   }
 
   def String getExportedNamesProvider(ExportModel model) {

com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/GeneratorUtil.java

@@ -55,7 +55,9 @@ protected GeneratorUtil() {
    */
   public static Set<EClass> allInstantiatedTypes(final Grammar grammar) {
     Set<EClass> result = Sets.newLinkedHashSet();
-    collectInstantiatedTypes(grammar, result);
+    if (grammar != null) { // no grammar -> no parser-instantiated subtypes
+      collectInstantiatedTypes(grammar, result);
+    }
     return result;
   }