Bug 8126 - Some augments are not being processed

[yangtools.git] / yang / yang-parser-impl / src / main / java / org / opendaylight / yangtools / yang / parser / stmt / rfc6020 / AugmentStatementImpl.java

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 47e59579de98ea69e5b5a9b7430b96c3cf7ec4a9..4069da268a01bfec41671d3914ca1e0fa0463e24 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
@@ -10,7 +10,6 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
 import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableList.Builder;
 import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -19,6 +18,7 @@ import java.util.Set;
 import java.util.regex.Pattern;
 import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.YangVersion;
 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
@@ -148,7 +148,7 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                         augmentTargetCtx.addEffectiveSubstatement(augmentSourceCtx);
                         updateAugmentOrder(augmentSourceCtx);
                     } catch (final SourceException e) {
-                        LOG.debug("Failed to add augmentation {} defined at {}",
+                        LOG.warn("Failed to add augmentation {} defined at {}",
                             augmentTargetCtx.getStatementSourceReference(),
                                 augmentSourceCtx.getStatementSourceReference(), e);
                     }
@@ -204,6 +204,12 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             final CopyType typeOfCopy = UsesStatement.class.equals(sourceCtx.getParentContext().getPublicDefinition()
                     .getDeclaredRepresentationClass()) ? CopyType.ADDED_BY_USES_AUGMENTATION
                     : CopyType.ADDED_BY_AUGMENTATION;
+            /*
+             * Since Yang 1.1, if an augmentation is made conditional with a
+             * "when" statement, it is allowed to add mandatory nodes.
+             */
+            final boolean skipCheckOfMandatoryNodes = YangVersion.VERSION_1_1.equals(sourceCtx.getRootVersion())
+                    && isConditionalAugmentStmt(sourceCtx);
 
             final Collection<StatementContextBase<?, ?, ?>> declared = sourceCtx.declaredSubstatements();
             final Collection<StatementContextBase<?, ?, ?>> effective = sourceCtx.effectiveSubstatements();
@@ -211,21 +217,36 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
 
             for (final StatementContextBase<?, ?, ?> originalStmtCtx : declared) {
                 if (StmtContextUtils.areFeaturesSupported(originalStmtCtx)) {
-                    copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer);
+                    copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
                 }
             }
             for (final StatementContextBase<?, ?, ?> originalStmtCtx : effective) {
-                copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer);
+                copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
             }
 
             targetCtx.addEffectiveSubstatements(buffer);
         }
 
+        /**
+         * Checks whether supplied statement context is conditional augment
+         * statement.
+         *
+         * @param ctx
+         *            statement context to be checked
+         *
+         * @return true if supplied statement context is conditional augment
+         *         statement, otherwise false
+         */
+        private static boolean isConditionalAugmentStmt(final StatementContextBase<?, ?, ?> ctx) {
+            return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT
+                    && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
+        }
+
         private static void copyStatement(final StatementContextBase<?, ?, ?> original,
                 final StatementContextBase<?, ?, ?> target, final CopyType typeOfCopy,
-                final Collection<StatementContextBase<?, ?, ?>> buffer) {
+                final Collection<StatementContextBase<?, ?, ?>> buffer, final boolean skipCheckOfMandatoryNodes) {
             if (needToCopyByAugment(original)) {
-                validateNodeCanBeCopiedByAugment(original, target, typeOfCopy);
+                validateNodeCanBeCopiedByAugment(original, target, typeOfCopy, skipCheckOfMandatoryNodes);
 
                 final StatementContextBase<?, ?, ?> copy = original.createCopy(target, typeOfCopy);
                 buffer.add(copy);
@@ -235,13 +256,14 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
         }
 
         private static void validateNodeCanBeCopiedByAugment(final StatementContextBase<?, ?, ?> sourceCtx,
-                final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy) {
+                final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy, final boolean skipCheckOfMandatoryNodes) {
 
             if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) {
                 return;
             }
 
-            if (typeOfCopy == CopyType.ADDED_BY_AUGMENTATION && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
+            if (!skipCheckOfMandatoryNodes && typeOfCopy == CopyType.ADDED_BY_AUGMENTATION
+                    && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
                 checkForMandatoryNodes(sourceCtx);
             }
 
@@ -272,10 +294,8 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                  * b) added to augment body also via uses of a grouping and
                  * such sub-statements are stored in effective sub-statements collection.
                  */
-                for (final StatementContextBase<?, ?, ?> sourceSubStatement : Iterables.concat(
-                        sourceCtx.declaredSubstatements(), sourceCtx.declaredSubstatements())) {
-                    checkForMandatoryNodes(sourceSubStatement);
-                }
+                sourceCtx.declaredSubstatements().forEach(Definition::checkForMandatoryNodes);
+                sourceCtx.effectiveSubstatements().forEach(Definition::checkForMandatoryNodes);
             }
 
             InferenceException.throwIf(StmtContextUtils.isMandatoryNode(sourceCtx),
@@ -309,11 +329,16 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                 }
 
                 /*
-                 * If target or one of its parent is a presence container from
-                 * the same module, return false and skip mandatory nodes
-                 * validation
+                 * If target or one of the target's ancestors from the same namespace
+                 * is a presence container
+                 * or is non-mandatory choice
+                 * or is non-mandatory list
+                 * return false and skip mandatory nodes validation, because these nodes
+                 * are not mandatory node containers according to RFC 6020 section 3.1.
                  */
-                if (StmtContextUtils.isPresenceContainer(targetCtx)) {
+                if (StmtContextUtils.isPresenceContainer(targetCtx)
+                        || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.CHOICE)
+                        || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.LIST)) {
                     return false;
                 }
             } while ((targetCtx = targetCtx.getParentContext()) != root);