Refactor InferenceAction

An inference action's prerequisite may only be accessed once the
action fires. Hence require a key context to give out the value
of a particular Prerequisite.

Also audit methods interfacing to StatementContextBase and lower
their expectations where possible.

Change-Id: I71cec8647d7e013598dcdf2faf9d0a46c5105938
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
(cherry picked from commit 7e0c23776039758abe103858c3f9afe490e3035c)

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java
index 3403aa3de00410e528c59edb1c4b1e2e7af53e2f..f1316ddd15e2ca8f8b350cae6a7a46a4c64281ed 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractDeclaredStatement.java
@@ -17,7 +17,6 @@ import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
 import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
 
 /**
  * Utility abstract base class for implementing declared statements.
@@ -26,8 +25,6 @@ import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
  * @param <A> Argument type.
  */
 public abstract class AbstractDeclaredStatement<A> implements DeclaredStatement<A> {
-
-
     private final A argument;
     private final String rawArgument;
     private final ImmutableList<? extends DeclaredStatement<?>> substatements;
@@ -44,7 +41,7 @@ public abstract class AbstractDeclaredStatement<A> implements DeclaredStatement<
          * original collection, which may contains references to mutable context.
          */
         substatements = ImmutableList.copyOf(Collections2.transform(context.declaredSubstatements(),
-            StatementContextBase::buildDeclared));
+            StmtContext::buildDeclared));
     }
 
     protected final <S extends DeclaredStatement<?>> S firstDeclared(final Class<S> type) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ModelActionBuilder.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ModelActionBuilder.java
index 5a41353972f1404d8fc98e1a586abb0e6b056012..1693b73c05813a596c0eb1e5193770d8194281a6 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ModelActionBuilder.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ModelActionBuilder.java
@@ -9,7 +9,6 @@ package org.opendaylight.yangtools.yang.parser.spi.meta;
 
 import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.EFFECTIVE_MODEL;
 
-import com.google.common.base.Supplier;
 import java.util.Collection;
 import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@@ -60,7 +59,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
  *
  * Action will be executed when:
  * <ul>
- * <li> {@link InferenceAction#apply()} - all prerequisites (and declared forward references) are met,
+ * <li> {@link InferenceAction#apply(InferenceContext)} - all prerequisites (and declared forward references) are met,
  * action could dereference them and start applying changes.
  * </li>
  * <li>{@link InferenceAction#prerequisiteFailed(Collection)} - semantic parser finished all other satisfied
@@ -83,21 +82,23 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
  *
  */
 public interface ModelActionBuilder {
+    interface InferenceContext {
+
+    }
 
     @FunctionalInterface
-    interface Prerequisite<T> extends Supplier<T> {
+    interface Prerequisite<T> {
         /**
          * Returns associated prerequisite once it is resolved.
          *
+         * @param ctx Inference context in which the prerequisite was satisfied
          * @return associated prerequisite once it is resolved.
          */
-        @Override
-        T get();
+        T resolve(InferenceContext ctx);
     }
 
     /**
      * User-defined inference action.
-     *
      */
     interface InferenceAction {
 
@@ -112,7 +113,7 @@ public interface ModelActionBuilder {
          *      Note that this exception be used for user to debug YANG sources,
          *      so should provide helpful context to fix issue in sources.
          */
-        void apply() throws InferenceException;
+        void apply(InferenceContext ctx) throws InferenceException;
 
         /**
          * Invoked once one of prerequisites was not met,
@@ -133,14 +134,21 @@ public interface ModelActionBuilder {
     }
 
     /**
-     * Action requires that the specified context transition to complete{@link ModelProcessingPhase#FULL_DECLARATION}
-     * phase.
+     * Action requires that the specified context transition to complete {@link ModelProcessingPhase#FULL_DECLARATION}
+     * phase and produce a declared statement.
      *
-     * @param context Statement context which needs to
-     * @return A {@link Prerequisite} returning the declared statement of the specified context.
+     * @param context Statement context which needs to complete the transition.
+     * @return A {@link Prerequisite} returning the declared statement of the requested context.
      */
     @Nonnull <D extends DeclaredStatement<?>> Prerequisite<D> requiresDeclared(StmtContext<?, ? extends D, ?> context);
 
+    /**
+     * Action requires that the specified context completes specified phase.
+     *
+     * @param context Statement context which needs to complete the transition.
+     * @param phase ModelProcessingPhase which must have completed
+     * @return A {@link Prerequisite} returning the requested context.
+     */
     @Nonnull <A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
         Prerequisite<StmtContext<A, D, E>> requiresCtx(StmtContext<A, D, E> context, ModelProcessingPhase phase);
 

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ReactorException.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ReactorException.java
index 9ab46d9f21c6edeee03a55974c4fa54b097480ca..b41c9b2012702055449a8faef6fb94af03fb9cad 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ReactorException.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ReactorException.java
@@ -10,20 +10,20 @@ package org.opendaylight.yangtools.yang.parser.spi.meta;
 import com.google.common.base.Preconditions;
 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
 
-
 public class ReactorException extends Exception {
-
     private static final long serialVersionUID = 1L;
+
     private final ModelProcessingPhase phase;
     private final SourceIdentifier sourceIdentifier;
 
-    public ReactorException(ModelProcessingPhase phase, String message, SourceIdentifier sourceId, Throwable cause) {
+    public ReactorException(final ModelProcessingPhase phase, final String message, final SourceIdentifier sourceId,
+            final Throwable cause) {
         super(message, cause);
         this.phase = Preconditions.checkNotNull(phase);
         this.sourceIdentifier = sourceId;
     }
 
-    public ReactorException(ModelProcessingPhase phase, String message, SourceIdentifier sourceId) {
+    public ReactorException(final ModelProcessingPhase phase, final String message, final SourceIdentifier sourceId) {
         super(message);
         this.phase = Preconditions.checkNotNull(phase);
         this.sourceIdentifier = sourceId;

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java
index da704e5df417057aae3d038f29ae419e5fe7594f..ad3b07d84e162c7539fa40d83957b6397f440ca8 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java
@@ -31,8 +31,6 @@ import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
 import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace.SupportedFeatures;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.RootStatementContext;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.UnknownStatementImpl;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangDataStatementImpl;
 
@@ -273,7 +271,7 @@ public final class StmtContextUtils {
             final Set<QName> supportedFeatures) {
         boolean isSupported = false;
         boolean containsIfFeature = false;
-        for (final StatementContextBase<?, ?, ?> stmt : stmtContext.declaredSubstatements()) {
+        for (final StmtContext<?, ?, ?> stmt : stmtContext.declaredSubstatements()) {
             if (YangStmtMapping.IF_FEATURE.equals(stmt.getPublicDefinition())) {
                 if (stmtContext.isInYangDataExtensionBody()) {
                     break;
@@ -299,7 +297,7 @@ public final class StmtContextUtils {
      *            statement context
      * @return true if it is a presence container
      */
-    public static boolean isPresenceContainer(final StatementContextBase<?, ?, ?> stmtCtx) {
+    public static boolean isPresenceContainer(final StmtContext<?, ?, ?> stmtCtx) {
         return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && containsPresenceSubStmt(stmtCtx);
     }
 
@@ -310,11 +308,11 @@ public final class StmtContextUtils {
      *            statement context
      * @return true if it is a non-presence container
      */
-    public static boolean isNonPresenceContainer(final StatementContextBase<?, ?, ?> stmtCtx) {
+    public static boolean isNonPresenceContainer(final StmtContext<?, ?, ?> stmtCtx) {
         return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && !containsPresenceSubStmt(stmtCtx);
     }
 
-    private static boolean containsPresenceSubStmt(final StatementContextBase<?, ?, ?> stmtCtx) {
+    private static boolean containsPresenceSubStmt(final StmtContext<?, ?, ?> stmtCtx) {
         return findFirstSubstatement(stmtCtx, PresenceStatement.class) != null;
     }
 
@@ -327,7 +325,7 @@ public final class StmtContextUtils {
      * @return true if it is a mandatory leaf, choice, anyxml, list or leaf-list
      *         according to RFC6020.
      */
-    public static boolean isMandatoryNode(final StatementContextBase<?, ?, ?> stmtCtx) {
+    public static boolean isMandatoryNode(final StmtContext<?, ?, ?> stmtCtx) {
         if (!(stmtCtx.getPublicDefinition() instanceof YangStmtMapping)) {
             return false;
         }
@@ -358,7 +356,7 @@ public final class StmtContextUtils {
      *         statement definition and if it is not mandatory leaf, choice,
      *         anyxml, list or leaf-list according to RFC6020
      */
-    public static boolean isNotMandatoryNodeOfType(final StatementContextBase<?, ?, ?> stmtCtx,
+    public static boolean isNotMandatoryNodeOfType(final StmtContext<?, ?, ?> stmtCtx,
             final StatementDefinition stmtDef) {
         return stmtCtx.getPublicDefinition().equals(stmtDef) && !isMandatoryNode(stmtCtx);
     }
@@ -403,8 +401,10 @@ public final class StmtContextUtils {
         Preconditions.checkNotNull(ctx);
         Preconditions.checkNotNull(ancestorType);
         Preconditions.checkNotNull(ancestorChildType);
+
         StmtContext<?, ?, ?> current = ctx.getParentContext();
-        while (!(current instanceof RootStatementContext)) {
+        StmtContext<?, ?, ?> parent = current.getParentContext();
+        while (parent != null) {
             if (ancestorType.equals(current.getPublicDefinition())) {
                 @SuppressWarnings("unchecked")
                 final Class<DT> ancestorChildTypeClass = (Class<DT>) ancestorChildType.getDeclaredRepresentationClass();
@@ -412,7 +412,9 @@ public final class StmtContextUtils {
                     return false;
                 }
             }
-            current = current.getParentContext();
+
+            current = parent;
+            parent = current.getParentContext();
         }
 
         return true;

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ModifierImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ModifierImpl.java
index 53747f24b9afd2bd968c756b06278167044e1216..e917f958ef65a026d840982fc7866999e79e551d 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ModifierImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/ModifierImpl.java
@@ -37,6 +37,8 @@ import org.slf4j.LoggerFactory;
 final class ModifierImpl implements ModelActionBuilder {
     private static final Logger LOG = LoggerFactory.getLogger(ModifierImpl.class);
 
+    private final InferenceContext ctx = new InferenceContext() { };
+
     private final Set<AbstractPrerequisite<?>> unsatisfied = new HashSet<>(1);
     private final Set<AbstractPrerequisite<?>> mutations = new HashSet<>(1);
 
@@ -88,7 +90,7 @@ final class ModifierImpl implements ModelActionBuilder {
 
     private void applyAction() {
         Preconditions.checkState(!actionApplied);
-        action.apply();
+        action.apply(ctx);
         actionApplied = true;
     }
 
@@ -250,8 +252,9 @@ final class ModifierImpl implements ModelActionBuilder {
         private T value;
 
         @Override
-        public final T get() {
-            Preconditions.checkState(isDone());
+        public final T resolve(final InferenceContext ctx) {
+            Preconditions.checkState(done);
+            Preconditions.checkArgument(ctx == ModifierImpl.this.ctx);
             return value;
         }
 
@@ -266,7 +269,7 @@ final class ModifierImpl implements ModelActionBuilder {
         }
 
         final <O> Prerequisite<O> transform(final Function<? super T, O> transformation) {
-            return () -> transformation.apply(get());
+            return ctx -> transformation.apply(resolve(ctx));
         }
 
         @Override

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
index 4069da268a01bfec41671d3914ca1e0fa0463e24..0aaaaee5483c9b7aab3a134e5f844b568aff97b6 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
@@ -44,7 +44,6 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
 import org.opendaylight.yangtools.yang.parser.spi.source.StmtOrderingNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.RootStatementContext;
 import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AugmentEffectiveStatementImpl;
 import org.slf4j.Logger;
@@ -126,8 +125,9 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             augmentAction.apply(new ModelActionBuilder.InferenceAction() {
 
                 @Override
-                public void apply() {
-                    final StatementContextBase<?, ?, ?> augmentTargetCtx = (StatementContextBase<?, ?, ?>) target.get();
+                public void apply(final ModelActionBuilder.InferenceContext ctx) {
+                    final StatementContextBase<?, ?, ?> augmentTargetCtx =
+                            (StatementContextBase<?, ?, ?>) target.resolve(ctx);
                     if (!isSupportedAugmentTarget(augmentTargetCtx)
                             || StmtContextUtils.isInExtensionBody(augmentTargetCtx)) {
                         augmentNode.setIsSupportedToBuildEffective(false);
@@ -237,7 +237,7 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
          * @return true if supplied statement context is conditional augment
          *         statement, otherwise false
          */
-        private static boolean isConditionalAugmentStmt(final StatementContextBase<?, ?, ?> ctx) {
+        private static boolean isConditionalAugmentStmt(final StmtContext<?, ?, ?> ctx) {
             return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT
                     && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
         }
@@ -255,8 +255,9 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             }
         }
 
-        private static void validateNodeCanBeCopiedByAugment(final StatementContextBase<?, ?, ?> sourceCtx,
-                final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy, final boolean skipCheckOfMandatoryNodes) {
+        private static void validateNodeCanBeCopiedByAugment(final StmtContext<?, ?, ?> sourceCtx,
+                final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy,
+                final boolean skipCheckOfMandatoryNodes) {
 
             if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) {
                 return;
@@ -271,7 +272,6 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                     .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
 
             for (final StatementContextBase<?, ?, ?> subStatement : targetSubStatements) {
-
                 final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
                         .getPublicDefinition().getDeclaredRepresentationClass());
                 final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(subStatement
@@ -285,7 +285,7 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             }
         }
 
-        private static void checkForMandatoryNodes(final StatementContextBase<?, ?, ?> sourceCtx) {
+        private static void checkForMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx) {
             if (StmtContextUtils.isNonPresenceContainer(sourceCtx)) {
                 /*
                  * We need to iterate over both declared and effective sub-statements,
@@ -304,8 +304,8 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                     sourceCtx.rawStatementArgument());
         }
 
-        private static boolean reguiredCheckOfMandatoryNodes(final StatementContextBase<?, ?, ?> sourceCtx,
-                StatementContextBase<?, ?, ?> targetCtx) {
+        private static boolean reguiredCheckOfMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx,
+                Mutable<?, ?, ?> targetCtx) {
             /*
              * If the statement argument is not QName, it cannot be mandatory
              * statement, therefore return false and skip mandatory nodes validation
@@ -315,7 +315,8 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             }
             final QName sourceStmtQName = (QName) sourceCtx.getStatementArgument();
 
-            final RootStatementContext<?, ?, ?> root = targetCtx.getRoot();
+            // RootStatementContext, for example
+            final Mutable<?, ?, ?> root = targetCtx.getRoot();
             do {
                 Verify.verify(targetCtx.getStatementArgument() instanceof QName,
                         "Argument of augment target statement must be QName.");
@@ -363,8 +364,7 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition());
         }
 
-        static boolean isSupportedAugmentTarget(final StatementContextBase<?, ?, ?> substatementCtx) {
-
+        static boolean isSupportedAugmentTarget(final StmtContext<?, ?, ?> substatementCtx) {
             /*
              * :TODO Substatement must be allowed augment target type e.g.
              * Container, etc... and must not be for example grouping, identity etc.
@@ -373,9 +373,8 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
              * the same QName. We must find the Container and the Grouping must be
              * ignored as disallowed augment target.
              */
-
-            final Collection<?> allowedAugmentTargets = substatementCtx.getFromNamespace(ValidationBundlesNamespace.class,
-                    ValidationBundleType.SUPPORTED_AUGMENT_TARGETS);
+            final Collection<?> allowedAugmentTargets = substatementCtx.getFromNamespace(
+                ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_AUGMENT_TARGETS);
 
             // if no allowed target is returned we consider all targets allowed
             return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty()
@@ -386,7 +385,6 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
         protected SubstatementValidator getSubstatementValidator() {
             return SUBSTATEMENT_VALIDATOR;
         }
-
     }
 
     @Nonnull

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java
index 2ea1f0a4f68f4ce150925274cbd03e841de6ad48..e0c5b7a5ef17392104ad1d3885d179aa86032cf8 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BaseStatementImpl.java
@@ -24,6 +24,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedIdentitiesNamespac
 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@@ -78,11 +79,11 @@ public class BaseStatementImpl extends AbstractDeclaredStatement<QName> implemen
 
                 baseIdentityAction.apply(new InferenceAction() {
                     @Override
-                    public void apply() {
-                        List<StmtContext<?, ?, ?>> derivedIdentities =
-                                baseStmtCtx.getFromNamespace(DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument());
+                    public void apply(final InferenceContext ctx) {
+                        List<StmtContext<?, ?, ?>> derivedIdentities = baseStmtCtx.getFromNamespace(
+                            DerivedIdentitiesNamespace.class, baseStmtCtx.getStatementArgument());
                         if (derivedIdentities == null) {
-                            derivedIdentities = new ArrayList<>();
+                            derivedIdentities = new ArrayList<>(1);
                             baseStmtCtx.addToNs(DerivedIdentitiesNamespace.class, baseIdentityQName, derivedIdentities);
                         }
                         derivedIdentities.add(baseParentCtx);

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java
index 8d91f3a238c5aede7efe639c0b2c5616eeec98d8..97faf388ccda5ac0399d50d00e0f46e2bdec3f29 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/BelongsToStatementImpl.java
@@ -23,6 +23,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
@@ -77,8 +78,8 @@ public class BelongsToStatementImpl extends AbstractDeclaredStatement<String>
 
             belongsToAction.apply(new InferenceAction() {
                 @Override
-                public void apply() {
-                    StmtContext<?, ?, ?> belongsToModuleCtx = belongsToPrereq.get();
+                public void apply(final InferenceContext ctx) {
+                    StmtContext<?, ?, ?> belongsToModuleCtx = belongsToPrereq.resolve(ctx);
 
                     belongsToCtx.addToNs(BelongsToModuleContext.class, belongsToModuleIdentifier, belongsToModuleCtx);
                     belongsToCtx.addToNs(BelongsToPrefixToModuleIdentifier.class,

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java
index 9de23b309f2ce8f70f68b6e36d4915e61f862bc0..2a1a9dd85f630e2a899f6264c34f6fcd36b4be3d 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java
@@ -31,6 +31,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@@ -143,40 +144,39 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
                     deviateAction.requiresCtx(deviateStmtCtx, ModelProcessingPhase.EFFECTIVE_MODEL);
 
             final Prerequisite<StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>>> targetCtxPrerequisite =
-                    deviateAction
-            .mutatesEffectiveCtx(deviateStmtCtx.getRoot(), SchemaNodeIdentifierBuildNamespace.class,
-                    deviationTarget);
-
-                    deviateAction.apply(new InferenceAction() {
-                        @Override
-                        public void apply() throws InferenceException {
-                            // FIXME once BUG-7760 gets fixed, there will be no need for these dirty casts
-                            final StatementContextBase<?, ?, ?> sourceNodeStmtCtx =
-                                    (StatementContextBase<?, ?, ?>) sourceCtxPrerequisite.get();
-                            final StatementContextBase<?, ?, ?> targetNodeStmtCtx =
-                                    (StatementContextBase<?, ?, ?>) targetCtxPrerequisite.get();
-
-                            switch (deviateKind) {
-                                case NOT_SUPPORTED:
-                                    targetNodeStmtCtx.setIsSupportedToBuildEffective(false);
-                                    break;
-                                case ADD:
-                                    performDeviateAdd(sourceNodeStmtCtx, targetNodeStmtCtx);
-                                    break;
-                                case REPLACE:
-                                    performDeviateReplace(sourceNodeStmtCtx, targetNodeStmtCtx);
-                                    break;
-                                case DELETE:
-                                    performDeviateDelete(sourceNodeStmtCtx, targetNodeStmtCtx);
-                            }
-                        }
-
-                        @Override
-                        public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
-                            throw new InferenceException(deviateStmtCtx.getParentContext().getStatementSourceReference(),
-                                    "Deviation target '%s' not found.", deviationTarget);
-                        }
-                    });
+                    deviateAction.mutatesEffectiveCtx(deviateStmtCtx.getRoot(),
+                        SchemaNodeIdentifierBuildNamespace.class,  deviationTarget);
+
+            deviateAction.apply(new InferenceAction() {
+                @Override
+                public void apply(final InferenceContext ctx) throws InferenceException {
+                    // FIXME once BUG-7760 gets fixed, there will be no need for these dirty casts
+                    final StatementContextBase<?, ?, ?> sourceNodeStmtCtx =
+                            (StatementContextBase<?, ?, ?>) sourceCtxPrerequisite.resolve(ctx);
+                    final StatementContextBase<?, ?, ?> targetNodeStmtCtx =
+                            (StatementContextBase<?, ?, ?>) targetCtxPrerequisite.resolve(ctx);
+
+                    switch (deviateKind) {
+                        case NOT_SUPPORTED:
+                            targetNodeStmtCtx.setIsSupportedToBuildEffective(false);
+                            break;
+                        case ADD:
+                            performDeviateAdd(sourceNodeStmtCtx, targetNodeStmtCtx);
+                            break;
+                        case REPLACE:
+                            performDeviateReplace(sourceNodeStmtCtx, targetNodeStmtCtx);
+                            break;
+                        case DELETE:
+                            performDeviateDelete(sourceNodeStmtCtx, targetNodeStmtCtx);
+                    }
+                }
+
+                @Override
+                public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
+                    throw new InferenceException(deviateStmtCtx.getParentContext().getStatementSourceReference(),
+                        "Deviation target '%s' not found.", deviationTarget);
+                }
+            });
         }
 
         private static boolean isDeviationSupported(final StmtContext.Mutable<DeviateKind, DeviateStatement,
@@ -282,7 +282,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
             }
         }
 
-        private static void deleteStatement(final StatementContextBase<?, ?, ?> stmtCtxToBeDeleted,
+        private static void deleteStatement(final StmtContext<?, ?, ?> stmtCtxToBeDeleted,
                 final StatementContextBase<?, ?, ?> targetCtx) {
             final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.getPublicDefinition();
             final String stmtArgument = stmtCtxToBeDeleted.rawStatementArgument();
@@ -313,16 +313,16 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
             return firstStmtDef.equals(secondStmtDef) && Objects.equals(firstStmtArg, secondStmtArg);
         }
 
-        private static void validateDeviationTarget(final StatementContextBase<?, ?, ?> deviateSubStmtCtx,
-                final StatementContextBase<?, ?, ?> targetCtx) {
+        private static void validateDeviationTarget(final StmtContext<?, ?, ?> deviateSubStmtCtx,
+                final StmtContext<?, ?, ?> targetCtx) {
             InferenceException.throwIf(!isSupportedDeviationTarget(deviateSubStmtCtx, targetCtx,
                     targetCtx.getRootVersion()), deviateSubStmtCtx.getStatementSourceReference(),
                     "%s is not a valid deviation target for substatement %s.",
                     targetCtx.getStatementArgument(), deviateSubStmtCtx.getPublicDefinition().getStatementName());
         }
 
-        private static boolean isSupportedDeviationTarget(final StatementContextBase<?, ?, ?> deviateSubstatementCtx,
-                final StatementContextBase<?, ?, ?> deviateTargetCtx, final YangVersion yangVersion) {
+        private static boolean isSupportedDeviationTarget(final StmtContext<?, ?, ?> deviateSubstatementCtx,
+                final StmtContext<?, ?, ?> deviateTargetCtx, final YangVersion yangVersion) {
             Set<StatementDefinition> supportedDeviationTargets =
                     YangValidationBundles.SUPPORTED_DEVIATION_TARGETS.get(deviateTargetCtx.getRootVersion(),
                             deviateSubstatementCtx.getPublicDefinition());

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java
index 42214a1fe9c84046f29981603d70ba8d912643e3..c429537e9137522aeda8f7b781d5a719695ca07f 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/ImportStatementDefinition.java
@@ -38,6 +38,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
@@ -99,8 +100,8 @@ public class ImportStatementDefinition extends
 
         importAction.apply(new InferenceAction() {
             @Override
-            public void apply() {
-                final StmtContext<?, ?, ?> importedModuleContext = imported.get();
+            public void apply(final InferenceContext ctx) {
+                final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx);
                 Verify.verify(moduleName.equals(importedModuleContext.getStatementArgument()));
                 final URI importedModuleNamespace = importedModuleContext.getFromNamespace(ModuleNameToNamespace.class,
                         moduleName);
@@ -152,7 +153,7 @@ public class ImportStatementDefinition extends
 
             importAction.apply(new InferenceAction() {
                 @Override
-                public void apply() {
+                public void apply(final InferenceContext ctx) {
                     StmtContext<?, ?, ?> importedModule = null;
                     ModuleIdentifier importedModuleIdentifier = null;
                     if (impIdentifier.getRevision() == SimpleDateFormatUtil.DEFAULT_DATE_IMP) {
@@ -165,11 +166,11 @@ public class ImportStatementDefinition extends
                     }
 
                     if (importedModule == null || importedModuleIdentifier == null) {
-                        importedModule = imported.get();
+                        importedModule = imported.resolve(ctx);
                         importedModuleIdentifier = impIdentifier;
                     }
 
-                    linkageTarget.get().addToNs(ImportedModuleContext.class, importedModuleIdentifier, importedModule);
+                    linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier, importedModule);
                     final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
                     stmt.addToNs(ImpPrefixToModuleIdentifier.class, impPrefix, importedModuleIdentifier);
 
@@ -209,7 +210,7 @@ public class ImportStatementDefinition extends
             return recentModuleEntry;
         }
 
-        private static ModuleIdentifier getImportedModuleIdentifier(final Mutable<String, ImportStatement, ?> stmt) {
+        private static ModuleIdentifier getImportedModuleIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
             Date revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
             if (revision == null) {
                 revision = SimpleDateFormatUtil.DEFAULT_DATE_IMP;
@@ -235,7 +236,7 @@ public class ImportStatementDefinition extends
 
             importAction.apply(new InferenceAction() {
                 @Override
-                public void apply() {
+                public void apply(final InferenceContext ctx) {
                     final Entry<SemVer, StmtContext<?, ?, ?>> importedModuleEntry= findRecentCompatibleModuleEntry(
                             impIdentifier.getName(), stmt);
 
@@ -252,7 +253,7 @@ public class ImportStatementDefinition extends
                                         .getName(), getRequestedImportVersion(stmt));
                     }
 
-                    linkageTarget.get().addToNs(ImportedModuleContext.class, importedModuleIdentifier, importedModule);
+                    linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier, importedModule);
                     final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
                     stmt.addToNs(ImpPrefixToModuleIdentifier.class, impPrefix, importedModuleIdentifier);
                     stmt.addToNs(ImpPrefixToSemVerModuleIdentifier.class, impPrefix, semVerModuleIdentifier);
@@ -272,7 +273,7 @@ public class ImportStatementDefinition extends
             });
         }
 
-        private static SemVer getRequestedImportVersion(final Mutable<?, ?, ?> impStmt) {
+        private static SemVer getRequestedImportVersion(final StmtContext<?, ?, ?> impStmt) {
             SemVer requestedImportVersion = impStmt.getFromNamespace(SemanticVersionNamespace.class, impStmt);
             if (requestedImportVersion == null) {
                 requestedImportVersion = Module.DEFAULT_SEMANTIC_VERSION;
@@ -281,7 +282,7 @@ public class ImportStatementDefinition extends
         }
 
         private static Entry<SemVer, StmtContext<?, ?, ?>> findRecentCompatibleModuleEntry(final String moduleName,
-                final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> impStmt) {
+                final StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> impStmt) {
             NavigableMap<SemVer, StmtContext<?, ?, ?>> allRelevantModulesMap = impStmt.getFromNamespace(
                     SemanticVersionModuleNamespace.class, moduleName);
             if (allRelevantModulesMap == null) {
@@ -298,7 +299,7 @@ public class ImportStatementDefinition extends
             return null;
         }
 
-        private static ModuleIdentifier getImportedModuleIdentifier(final Mutable<String, ImportStatement, ?> impStmt) {
+        private static ModuleIdentifier getImportedModuleIdentifier(final StmtContext<String, ImportStatement, ?> impStmt) {
             return ModuleIdentifierImpl.create(impStmt.getStatementArgument(), Optional.empty(),
                     Optional.of(SimpleDateFormatUtil.DEFAULT_DATE_IMP));
         }

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java
index 77edcaee7c11f9cf8edb3ce2928ba583e26ebfe8..7d4adc98f981c98a408ab5fd9c48f11955addaf9 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/IncludeStatementImpl.java
@@ -31,6 +31,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
@@ -86,8 +87,8 @@ public class IncludeStatementImpl extends AbstractDeclaredStatement<String> impl
 
             includeAction.apply(new InferenceAction() {
                 @Override
-                public void apply() {
-                    final StmtContext<?, ?, ?> includedSubModuleContext = requiresCtxPrerequisite.get();
+                public void apply(final InferenceContext ctx) {
+                    final StmtContext<?, ?, ?> includedSubModuleContext = requiresCtxPrerequisite.resolve(ctx);
 
                     stmt.addToNs(IncludedModuleContext.class, includeSubmoduleIdentifier,
                             includedSubModuleContext);
@@ -104,7 +105,7 @@ public class IncludeStatementImpl extends AbstractDeclaredStatement<String> impl
             });
         }
 
-        private static ModuleIdentifier getIncludeSubmoduleIdentifier(final Mutable<String, IncludeStatement, ?> stmt) {
+        private static ModuleIdentifier getIncludeSubmoduleIdentifier(final StmtContext<String, IncludeStatement, ?> stmt) {
 
             final String subModuleName = stmt.getStatementArgument();
 

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java
index 992404533e13a5baa4d4ae50b72a86556f09c539..968b93c884a43c44b446779852e9c3ce9d2fde88 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/TypeStatementImpl.java
@@ -40,6 +40,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
@@ -226,7 +227,7 @@ public class TypeStatementImpl extends AbstractDeclaredStatement<String>
              */
             typeAction.apply(new InferenceAction() {
                 @Override
-                public void apply() {
+                public void apply(final InferenceContext ctx) {
                     // Intentional NOOP
                 }
 

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
index 32ace4cbc881450bb89583d29cdf15b332427282..6682a3ab54e8c9a3da85ab95d3857d8162939fb6 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
@@ -35,6 +35,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
 import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
@@ -103,9 +104,9 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
             usesAction.apply(new InferenceAction() {
 
                 @Override
-                public void apply() {
-                    final StatementContextBase<?, ?, ?> targetNodeStmtCtx = (StatementContextBase<?, ?, ?>) targetNodePre.get();
-                    final StatementContextBase<?, ?, ?> sourceGrpStmtCtx = (StatementContextBase<?, ?, ?>) sourceGroupingPre.get();
+                public void apply(final InferenceContext ctx) {
+                    final StatementContextBase<?, ?, ?> targetNodeStmtCtx = (StatementContextBase<?, ?, ?>) targetNodePre.resolve(ctx);
+                    final StatementContextBase<?, ?, ?> sourceGrpStmtCtx = (StatementContextBase<?, ?, ?>) sourceGroupingPre.resolve(ctx);
 
                     try {
                         copyFromSourceToTarget(sourceGrpStmtCtx, targetNodeStmtCtx, usesNode);
@@ -198,7 +199,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
      * @throws SourceException
      *             instance of SourceException
      */
-    private static void copyFromSourceToTarget(final StatementContextBase<?, ?, ?> sourceGrpStmtCtx,
+    private static void copyFromSourceToTarget(final StmtContext<?, ?, ?> sourceGrpStmtCtx,
             final StatementContextBase<?, ?, ?> targetCtx,
             final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
         final Collection<StatementContextBase<?, ?, ?>> declared = sourceGrpStmtCtx.declaredSubstatements();
@@ -274,7 +275,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
         }
     }
 
-    private static boolean areFeaturesSupported(final StatementContextBase<?, ?, ?> subStmtCtx) {
+    private static boolean areFeaturesSupported(final Mutable<?, ?, ?> subStmtCtx) {
         /*
          * In case of Yang 1.1, checks whether features are supported.
          */
@@ -345,7 +346,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
         return ALLOWED_TO_ADD_BY_REFINE_DEF_SET.contains(publicDefinition);
     }
 
-    private static boolean isSupportedRefineSubstatement(final StatementContextBase<?, ?, ?> refineSubstatementCtx) {
+    private static boolean isSupportedRefineSubstatement(final StmtContext<?, ?, ?> refineSubstatementCtx) {
         final Collection<?> supportedRefineSubstatements = refineSubstatementCtx.getFromNamespace(
                 ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_REFINE_SUBSTATEMENTS);
 
@@ -354,9 +355,8 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
                 || StmtContextUtils.isUnknownStatement(refineSubstatementCtx);
     }
 
-    private static boolean isSupportedRefineTarget(final StatementContextBase<?, ?, ?> refineSubstatementCtx,
-            final StatementContextBase<?, ?, ?> refineTargetNodeCtx) {
-
+    private static boolean isSupportedRefineTarget(final StmtContext<?, ?, ?> refineSubstatementCtx,
+            final StmtContext<?, ?, ?> refineTargetNodeCtx) {
         final Collection<?> supportedRefineTargets = YangValidationBundles.SUPPORTED_REFINE_TARGETS
                 .get(refineSubstatementCtx.getPublicDefinition());
 
@@ -365,7 +365,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
     }
 
 
-    private static QNameModule getNewQNameModule(final StatementContextBase<?, ?, ?> targetCtx,
+    private static QNameModule getNewQNameModule(final StmtContext<?, ?, ?> targetCtx,
             final StmtContext<?, ?, ?> stmtContext) {
         if (targetCtx.isRootContext()) {
             return targetCtx.getFromNamespace(ModuleCtxToModuleQName.class, targetCtx);