Rework BindingRuntimeTypes

[mdsal.git] / binding / mdsal-binding-generator / src / main / java / org / opendaylight / mdsal / binding / generator / impl / reactor / GeneratorReactor.java

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java
index 4cfde54f751f866bd885059b4500016198aad7e6..a201f5a5ab4471a51127b88d5704374017a5ac55 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java
@@ -71,6 +71,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
     private State state = State.INITIALIZED;
 
     public GeneratorReactor(final EffectiveModelContext context) {
+        super(context);
         inferenceStack = SchemaInferenceStack.of(context);
 
         // Construct modules and their subtrees. Dependency sort is very much needed here, as it establishes order of
@@ -145,9 +146,9 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
         }
         LOG.trace("Processing linkage of {} augment generators", augments.size());
 
-        // Step 1c: ... finally establish linkage along the reverse uses/augment axis. This is needed to route generated
-        //          type manifestations (isAddedByUses/isAugmenting) to their type generation sites. Since generator
-        //          tree iteration order does not match dependencies, we may need to perform multiple passes.
+        // Step 1c: Establish linkage along the reverse uses/augment axis. This is needed to route generated type
+        //          manifestations (isAddedByUses/isAugmenting) to their type generation sites. Since generator tree
+        //          iteration order does not match dependencies, we may need to perform multiple passes.
         for (ModuleGenerator module : children) {
             verify(module.linkOriginalGenerator(), "Module %s failed to link", module);
         }
@@ -163,7 +164,16 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
                 break;
             }
 
-            verify(progress, "Failed to make progress on linking of original generators");
+            if (!progress) {
+                final var ex = new VerifyException("Failed to make progress on linking of original generators");
+                for (var augment : augments) {
+                    ex.addSuppressed(new IllegalStateException(augment + " is incomplete"));
+                }
+                for (var module : unlinkedModules) {
+                    ex.addSuppressed(new IllegalStateException(module + " remains unlinked"));
+                }
+                throw ex;
+            }
         }
 
         /*
@@ -236,13 +246,13 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
             gen.ensureMember();
             collectCollisionDomains(result, gen);
             if (gen instanceof AbstractCompositeGenerator) {
-                result.add(((AbstractCompositeGenerator<?>) gen).domain());
+                result.add(((AbstractCompositeGenerator<?, ?>) gen).domain());
             }
         }
     }
 
     @Override
-    <E extends EffectiveStatement<QName, ?>, G extends AbstractExplicitGenerator<E>> G resolveTreeScoped(
+    <E extends EffectiveStatement<QName, ?>, G extends AbstractExplicitGenerator<E, ?>> G resolveTreeScoped(
             final Class<G> type, final QName argument) {
         LOG.trace("Searching for tree-scoped argument {} at {}", argument, stack);
 
@@ -288,7 +298,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
     }
 
     @Override
-    AbstractTypeObjectGenerator<?> resolveLeafref(final PathExpression path) {
+    AbstractTypeObjectGenerator<?, ?> resolveLeafref(final PathExpression path) {
         LOG.trace("Resolving path {}", path);
         verify(inferenceStack.isEmpty(), "Unexpected data tree state %s", inferenceStack);
         try {
@@ -310,7 +320,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
         }
     }
 
-    private @NonNull AbstractTypeAwareGenerator<?> strictResolvePath(final @NonNull PathExpression path) {
+    private @NonNull AbstractTypeAwareGenerator<?, ?, ?> strictResolvePath(final @NonNull PathExpression path) {
         try {
             inferenceStack.resolvePathExpression(path);
         } catch (IllegalArgumentException e) {
@@ -319,7 +329,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
         return mapToGenerator();
     }
 
-    private @Nullable AbstractTypeAwareGenerator<?> lenientResolveLeafref(final @NonNull PathExpression path) {
+    private @Nullable AbstractTypeAwareGenerator<?, ?, ?> lenientResolveLeafref(final @NonNull PathExpression path) {
         try {
             inferenceStack.resolvePathExpression(path);
         } catch (IllegalArgumentException e) {
@@ -330,7 +340,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
     }
 
     // Map a statement to the corresponding generator
-    private @NonNull AbstractTypeAwareGenerator<?> mapToGenerator() {
+    private @NonNull AbstractTypeAwareGenerator<?, ?, ?> mapToGenerator() {
         // Some preliminaries first: we need to be in the correct module to walk the path
         final ModuleEffectiveStatement module = inferenceStack.currentModule();
         final ModuleGenerator gen = verifyNotNull(generators.get(module.localQNameModule()),
@@ -338,9 +348,9 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
 
         // Now kick of the search
         final List<EffectiveStatement<?, ?>> stmtPath = inferenceStack.toInference().statementPath();
-        final AbstractExplicitGenerator<?> found = gen.findGenerator(stmtPath);
+        final AbstractExplicitGenerator<?, ?> found = gen.findGenerator(stmtPath);
         if (found instanceof AbstractTypeAwareGenerator) {
-            return (AbstractTypeAwareGenerator<?>) found;
+            return (AbstractTypeAwareGenerator<?, ?, ?>) found;
         }
         throw new VerifyException("Statements " + stmtPath + " resulted in unexpected " + found);
     }
@@ -350,7 +360,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
         for (Generator child : parent) {
             if (child instanceof AbstractCompositeGenerator) {
                 LOG.trace("Visiting composite {}", child);
-                final AbstractCompositeGenerator<?> composite = (AbstractCompositeGenerator<?>) child;
+                final var composite = (AbstractCompositeGenerator<?, ?>) child;
                 stack.push(composite);
                 composite.linkUsesDependencies(this);
                 linkUsesDependencies(composite);
@@ -364,12 +374,19 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
 
         final var it = items.iterator();
         while (it.hasNext()) {
-            final var tmp = function.apply(it.next());
-            if (tmp != LinkageProgress.NONE) {
-                progress = true;
+            final var item = it.next();
+            final var tmp = function.apply(item);
+            if (tmp == LinkageProgress.NONE) {
+                LOG.debug("No progress made linking {}", item);
+                continue;
             }
+
+            progress = true;
             if (tmp == LinkageProgress.DONE) {
+                LOG.debug("Finished linking {}", item);
                 it.remove();
+            } else {
+                LOG.debug("Progress made linking {}", item);
             }
         }
 
@@ -379,7 +396,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
     private void linkDependencies(final Iterable<? extends Generator> parent) {
         for (Generator child : parent) {
             if (child instanceof AbstractDependentGenerator) {
-                ((AbstractDependentGenerator<?>) child).linkDependencies(this);
+                ((AbstractDependentGenerator<?, ?>) child).linkDependencies(this);
             } else if (child instanceof AbstractCompositeGenerator) {
                 stack.push(child);
                 linkDependencies(child);
@@ -392,7 +409,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable
         for (Generator child : parent) {
             stack.push(child);
             if (child instanceof AbstractTypeObjectGenerator) {
-                ((AbstractTypeObjectGenerator<?>) child).bindTypeDefinition(this);
+                ((AbstractTypeObjectGenerator<?, ?>) child).bindTypeDefinition(this);
             } else if (child instanceof AbstractCompositeGenerator) {
                 bindTypeDefinition(child);
             }