Improve OriginalLink safety

The links to previous and original statement need to match our
statement, otherwise we are in trouble. While we do not verify this
at runtime (yet), improve type definitions to carry these around.

JIRA: MDSAL-696
Change-Id: I3bcc1c3b0d2e3f74a0727f8bfa6b2f1e1c578f67
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
index 810d2d876d493a3e36a6187c4e3f5da57e8249f0..450dab4e2e232f27943688f783e7359d98e6c9d3 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
@@ -329,20 +329,20 @@ abstract class AbstractCompositeGenerator<T extends EffectiveStatement<?, ?>> ex
     }
 
     @Override
-    final AbstractCompositeGenerator<?> getOriginal() {
-        return (AbstractCompositeGenerator<?>) super.getOriginal();
+    final AbstractCompositeGenerator<T> getOriginal() {
+        return (AbstractCompositeGenerator<T>) super.getOriginal();
     }
 
     @Override
-    final AbstractCompositeGenerator<?> tryOriginal() {
-        return (AbstractCompositeGenerator<?>) super.tryOriginal();
+    final AbstractCompositeGenerator<T> tryOriginal() {
+        return (AbstractCompositeGenerator<T>) super.tryOriginal();
     }
 
-    final @Nullable OriginalLink originalChild(final QName childQName) {
+    final <S extends EffectiveStatement<?, ?>> @Nullable OriginalLink<S> originalChild(final QName childQName) {
         // First try groupings/augments ...
         var found = findInferredGenerator(childQName);
         if (found != null) {
-            return OriginalLink.partial(found);
+            return (OriginalLink<S>) OriginalLink.partial(found);
         }
 
         // ... no luck, we really need to start looking at our origin
@@ -351,7 +351,7 @@ abstract class AbstractCompositeGenerator<T extends EffectiveStatement<?, ?>> ex
             final QName prevQName = childQName.bindTo(prev.getQName().getModule());
             found = prev.findSchemaTreeGenerator(prevQName);
             if (found != null) {
-                return  found.originalLink();
+                return (OriginalLink<S>) found.originalLink();
             }
         }
 

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
index fca1b5bacb8cad53b94b1e42d473a8bc8e11e34f..10cac0c71c5d2b669934ae1e86689a40bb15acb0 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
@@ -50,11 +50,11 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      *   <li>a generator which is one step closer to the original definition</li>
      * </ul>
      */
-    private AbstractExplicitGenerator<?> prev;
+    private AbstractExplicitGenerator<T> prev;
     /**
      * Field holding the original incarnation, i.e. the terminal node along {@link #prev} links.
      */
-    private AbstractExplicitGenerator<?> orig;
+    private AbstractExplicitGenerator<T> orig;
 
     AbstractExplicitGenerator(final T statement) {
         this.statement = requireNonNull(statement);
@@ -104,7 +104,7 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
                 return true;
             }
 
-            final var link = getParent().originalChild(getQName());
+            final var link = getParent().<T>originalChild(getQName());
             if (link == null) {
                 LOG.trace("Cannot link {} yet", this);
                 return false;
@@ -134,7 +134,7 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      *
      * @return Previous incarnation or {@code null}
      */
-    final @Nullable AbstractExplicitGenerator<?> previous() {
+    final @Nullable AbstractExplicitGenerator<T> previous() {
         final var local = verifyNotNull(prev, "Generator %s does not have linkage to previous instance resolved", this);
         return local == this ? null : local;
     }
@@ -144,11 +144,11 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      *
      * @return Original incarnation of this generator
      */
-    @NonNull AbstractExplicitGenerator<?> getOriginal() {
+    @NonNull AbstractExplicitGenerator<T> getOriginal() {
         return verifyNotNull(orig, "Generator %s does not have linkage to original instance resolved", this);
     }
 
-    @Nullable AbstractExplicitGenerator<?> tryOriginal() {
+    @Nullable AbstractExplicitGenerator<T> tryOriginal() {
         return orig;
     }
 
@@ -157,7 +157,7 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      *
      * @return Link towards the original generator.
      */
-    final @NonNull OriginalLink originalLink() {
+    final @NonNull OriginalLink<T> originalLink() {
         final var local = prev;
         if (local == null) {
             return OriginalLink.partial(this);

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java
index 9794da4cf8e8d839f5c1f40bc8a934922a3aefd5..3d9009a42b4c6dfc068e38f2f7bb22799df5178b 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java
@@ -13,26 +13,27 @@ import com.google.common.base.MoreObjects;
 import com.google.common.base.MoreObjects.ToStringHelper;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 
 /**
  * Link to the original definition of an {@link AbstractExplicitGenerator}.
  */
 // FIXME: sealed when we have JDK17+
-abstract class OriginalLink {
-    private static final class Complete extends OriginalLink {
-        private final @NonNull AbstractExplicitGenerator<?> original;
+abstract class OriginalLink<T extends EffectiveStatement<?, ?>> {
+    private static final class Complete<T extends EffectiveStatement<?, ?>> extends OriginalLink<T> {
+        private final @NonNull AbstractExplicitGenerator<T> original;
 
-        Complete(final AbstractExplicitGenerator<?> original) {
+        Complete(final AbstractExplicitGenerator<T> original) {
             this.original = requireNonNull(original);
         }
 
         @Override
-        AbstractExplicitGenerator<?> previous() {
+        AbstractExplicitGenerator<T> previous() {
             return original;
         }
 
         @Override
-        @NonNull AbstractExplicitGenerator<?> original() {
+        @NonNull AbstractExplicitGenerator<T> original() {
             return original;
         }
 
@@ -42,21 +43,21 @@ abstract class OriginalLink {
         }
     }
 
-    private static final class Partial extends OriginalLink {
-        private final @NonNull AbstractExplicitGenerator<?> previous;
-        private AbstractExplicitGenerator<?> original;
+    private static final class Partial<T extends EffectiveStatement<?, ?>> extends OriginalLink<T> {
+        private final @NonNull AbstractExplicitGenerator<T> previous;
+        private AbstractExplicitGenerator<T> original;
 
-        Partial(final AbstractExplicitGenerator<?> previous) {
+        Partial(final AbstractExplicitGenerator<T> previous) {
             this.previous = requireNonNull(previous);
         }
 
         @Override
-        AbstractExplicitGenerator<?> previous() {
+        AbstractExplicitGenerator<T> previous() {
             return previous;
         }
 
         @Override
-        AbstractExplicitGenerator<?> original() {
+        AbstractExplicitGenerator<T> original() {
             if (original == null) {
                 final var link = previous.originalLink();
                 if (link instanceof Complete || link.previous() != previous) {
@@ -76,17 +77,19 @@ abstract class OriginalLink {
         // Hidden on purpose
     }
 
-    static @NonNull OriginalLink complete(final AbstractExplicitGenerator<?> original) {
-        return new Complete(original);
+    static <T extends EffectiveStatement<?, ?>> @NonNull OriginalLink<T> complete(
+            final AbstractExplicitGenerator<T> original) {
+        return new Complete<>(original);
     }
 
-    static @NonNull OriginalLink partial(final AbstractExplicitGenerator<?> previous) {
-        return new Partial(previous);
+    static <T extends EffectiveStatement<?, ?>> @NonNull OriginalLink<T> partial(
+            final AbstractExplicitGenerator<T> previous) {
+        return new Partial<>(previous);
     }
 
-    abstract @NonNull AbstractExplicitGenerator<?> previous();
+    abstract @NonNull AbstractExplicitGenerator<T> previous();
 
-    abstract @Nullable AbstractExplicitGenerator<?> original();
+    abstract @Nullable AbstractExplicitGenerator<T> original();
 
     abstract ToStringHelper addToStringAttributes(ToStringHelper helper);