Return ReactorStmtCtx from ensureCompletedPhase()

We end up casting things around the verification done by
ensureCompletedPhase(). Just return the verified statement, which allows
us to tighten the signature of buffer collections.

Change-Id: Id812948f0229b112d9da64ed8d09e916daa62cd9
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java
index 9349e3ff6ca2b5c6f31d462e85b96cc19c810075..f5a00a14991712bb0e2bf6001c6be3ed561458e4 100644 (file)
--- a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java
+++ b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java
@@ -463,8 +463,7 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         final Mutable<QName, Y, Z> ret = (Mutable<QName, Y, Z>) copySubstatement((Mutable<?, ?, ?>) template)
             .orElseThrow(
                 () -> new InferenceException(this, "Failed to materialize child %s template %s", qname, template));
-        ensureCompletedPhase(ret);
-        addMaterialized(template, ret);
+        addMaterialized(template, ensureCompletedPhase(ret));
 
         LOG.debug("Child {} materialized", qname);
         return ret;
@@ -535,7 +534,7 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         final Collection<? extends StatementContextBase<?, ?, ?>> declared = prototype.mutableDeclaredSubstatements();
         final Collection<? extends Mutable<?, ?, ?>> effective = prototype.mutableEffectiveSubstatements();
 
-        final List<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+        final var buffer = new ArrayList<ReactorStmtCtx<?, ?, ?>>(declared.size() + effective.size());
         for (final Mutable<?, ?, ?> stmtContext : declared) {
             if (stmtContext.isSupportedByFeatures()) {
                 copySubstatement(stmtContext, buffer, materializedSchemaTree);
@@ -546,7 +545,7 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         }
 
         final List<ReactorStmtCtx<?, ?, ?>> ret = beforeAddEffectiveStatementUnsafe(ImmutableList.of(), buffer.size());
-        ret.addAll((Collection) buffer);
+        ret.addAll(buffer);
         substatements = ret;
         setModified();
 
@@ -564,7 +563,7 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         return effective == null ? null : new EffectiveCopy(stmt, effective);
     }
 
-    private void copySubstatement(final Mutable<?, ?, ?> substatement, final Collection<Mutable<?, ?, ?>> buffer,
+    private void copySubstatement(final Mutable<?, ?, ?> substatement, final Collection<ReactorStmtCtx<?, ?, ?>> buffer,
             final Map<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>> materializedSchemaTree) {
         // Consult materialized substatements. We are in a copy operation and will end up throwing materialized
         // statements away -- hence we do not perform Map.remove() to save ourselves a mutation operation.
@@ -574,8 +573,7 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         final ReactorStmtCtx<?, ?, ?> materialized = findMaterialized(materializedSchemaTree, substatement);
         if (materialized == null) {
             copySubstatement(substatement).ifPresent(copy -> {
-                ensureCompletedPhase(copy);
-                buffer.add(copy);
+                buffer.add(ensureCompletedPhase(copy));
             });
         } else {
             buffer.add(materialized);
@@ -586,7 +584,7 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
         return substatement.copyAsChildOf(this, childCopyType(), targetModule);
     }
 
-    private void addMaterialized(final StmtContext<?, ?, ?> template, final Mutable<?, ?, ?> copy) {
+    private void addMaterialized(final StmtContext<?, ?, ?> template, final ReactorStmtCtx<?, ?, ?> copy) {
         final HashMap<StmtContext<?, ?, ?>, ReactorStmtCtx<?, ?, ?>> materializedSchemaTree;
         if (substatements == null) {
             // Lazy initialization of backing map. We do not expect this to be used often or multiple times -- each hit
@@ -601,8 +599,7 @@ final class InferredStatementContext<A, D extends DeclaredStatement<A>, E extend
             materializedSchemaTree = castMaterialized(substatements);
         }
 
-        final StmtContext<?, ?, ?> existing = materializedSchemaTree.put(template,
-            (StatementContextBase<?, ?, ?>) copy);
+        final var existing = materializedSchemaTree.put(template, copy);
         if (existing != null) {
             throw new VerifyException(
                 "Unexpected duplicate request for " + copy.argument() + " previous result was " + existing);

diff --git a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
index c7871bc0dd00aba2734b43ec5f38a20b333d3ebe..3ee005a363e0105327c909a1c9b33f2f6967c186 100644 (file)
--- a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
+++ b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
@@ -377,8 +377,10 @@ abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E extends
     abstract Iterator<ReactorStmtCtx<?, ?, ?>> effectiveChildrenToComplete();
 
     // exposed for InferredStatementContext only
-    final void ensureCompletedPhase(final Mutable<?, ?, ?> stmt) {
-        ensureCompletedExecution(verifyStatement(stmt));
+    final ReactorStmtCtx<?, ?, ?> ensureCompletedPhase(final Mutable<?, ?, ?> stmt) {
+        final var ret = verifyStatement(stmt);
+        ensureCompletedExecution(ret);
+        return ret;
     }
 
     // Make sure target statement has transitioned at least to our phase (if we have one). This method is just before we