X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=parser%2Fyang-parser-rfc7950%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Frfc7950%2Fstmt%2Fuses%2FUsesStatementSupport.java;h=f2d2f24a8f7da699936424a0e256a97817501caa;hb=0e0a54e3b39d7fcc26709fea86a694d8a6cad41b;hp=1718bc3218400b7439b401d42953e09ae200838f;hpb=3dc5b4125327e1a27d5b070d0c6754f1642b96ed;p=yangtools.git diff --git a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java index 1718bc3218..f2d2f24a8f 100644 --- a/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java +++ b/parser/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/uses/UsesStatementSupport.java @@ -39,14 +39,15 @@ import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement; import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatementDecorators; import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements; -import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins; import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration; import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils; import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.refine.RefineTargetNamespace; import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace; import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport; +import org.opendaylight.yangtools.yang.parser.spi.meta.BoundStmtCtx; import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; @@ -63,7 +64,6 @@ import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; 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.StatementContextBase; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -102,22 +102,20 @@ public final class UsesStatementSupport final Prerequisite> sourceGroupingPre = usesAction.requiresCtx(usesNode, GroupingNamespace.class, groupingName, ModelProcessingPhase.EFFECTIVE_MODEL); - final Prerequisite> targetNodePre = usesAction.mutatesEffectiveCtx( + final Prerequisite> targetNodePre = usesAction.mutatesEffectiveCtx( usesNode.getParentContext()); usesAction.apply(new InferenceAction() { @Override public void apply(final InferenceContext ctx) { - final StatementContextBase targetNodeStmtCtx = - (StatementContextBase) targetNodePre.resolve(ctx); - final StatementContextBase sourceGrpStmtCtx = - (StatementContextBase) sourceGroupingPre.resolve(ctx); + final Mutable targetNodeStmtCtx = targetNodePre.resolve(ctx); + final StmtContext sourceGrpStmtCtx = sourceGroupingPre.resolve(ctx); copyFromSourceToTarget(sourceGrpStmtCtx, targetNodeStmtCtx, usesNode); resolveUsesNode(usesNode, targetNodeStmtCtx); StmtContextUtils.validateIfFeatureAndWhenOnListKeys(usesNode); - usesNode.addToNs(SourceGroupingNamespace.class, Empty.getInstance(), sourceGrpStmtCtx); + usesNode.addToNs(SourceGroupingNamespace.class, Empty.value(), sourceGrpStmtCtx); } @Override @@ -130,8 +128,8 @@ public final class UsesStatementSupport } @Override - protected UsesStatement createDeclared(final StmtContext ctx, - final ImmutableList> substatements) { + protected UsesStatement createDeclared(final BoundStmtCtx ctx, + final ImmutableList> substatements) { return DeclaredStatements.createUses(ctx.getRawArgument(), ctx.getArgument(), substatements); } @@ -144,11 +142,11 @@ public final class UsesStatementSupport protected UsesEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { final EffectiveStatement source = - verifyNotNull(stmt.getFromNamespace(SourceGroupingNamespace.class, Empty.getInstance())).buildEffective(); + verifyNotNull(stmt.getFromNamespace(SourceGroupingNamespace.class, Empty.value())).buildEffective(); verify(source instanceof GroupingDefinition, "Unexpected source %s", source); final GroupingDefinition sourceGrouping = (GroupingDefinition) source; - final int flags = EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), substatements); + final int flags = EffectiveStmtUtils.historyAndStatusFlags(stmt.history(), substatements); final QName argument = stmt.getArgument(); final UsesStatement declared = stmt.declared(); @@ -195,21 +193,25 @@ public final class UsesStatementSupport */ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD", justification = "https://github.com/spotbugs/spotbugs/issues/811") - private static void copyFromSourceToTarget(final Mutable sourceGrpStmtCtx, - final StatementContextBase targetCtx, - final Mutable usesNode) { - final Collection> declared = sourceGrpStmtCtx.mutableDeclaredSubstatements(); - final Collection> effective = sourceGrpStmtCtx.mutableEffectiveSubstatements(); - final Collection> buffer = new ArrayList<>(declared.size() + effective.size()); + private static void copyFromSourceToTarget(final StmtContext sourceGrpStmtCtx, + final Mutable targetCtx, final Mutable usesNode) { + final var declared = sourceGrpStmtCtx.declaredSubstatements(); + final var effective = sourceGrpStmtCtx.effectiveSubstatements(); + final var buffer = new ArrayList>(declared.size() + effective.size()); final QNameModule newQNameModule = getNewQNameModule(targetCtx, sourceGrpStmtCtx); - for (final Mutable original : declared) { - if (original.isSupportedByFeatures() && shouldCopy(original)) { - original.copyAsChildOf(targetCtx, CopyType.ADDED_BY_USES, newQNameModule).ifPresent(buffer::add); + for (StmtContext original : declared) { + if (shouldCopy(original)) { + original.copyAsChildOf(targetCtx, CopyType.ADDED_BY_USES, newQNameModule).ifPresent(copy -> { + if (!original.isSupportedByFeatures() || !original.isSupportedToBuildEffective()) { + copy.setUnsupported(); + } + buffer.add(copy); + }); } } - for (final Mutable original : effective) { + for (StmtContext original : effective) { if (shouldCopy(original)) { original.copyAsChildOf(targetCtx, CopyType.ADDED_BY_USES, newQNameModule).ifPresent(buffer::add); } @@ -277,7 +279,7 @@ public final class UsesStatementSupport justification = "https://github.com/spotbugs/spotbugs/issues/811") private static void resolveUsesNode(final Mutable usesNode, final StmtContext targetNodeStmtCtx) { - for (final Mutable subStmtCtx : usesNode.mutableDeclaredSubstatements()) { + for (Mutable subStmtCtx : usesNode.mutableDeclaredSubstatements()) { if (subStmtCtx.producesDeclared(RefineStatement.class) && areFeaturesSupported(subStmtCtx)) { performRefine(subStmtCtx, targetNodeStmtCtx); } @@ -296,6 +298,8 @@ public final class UsesStatementSupport InferenceException.throwIf(!(refineArgument instanceof SchemaNodeIdentifier), subStmtCtx, "Invalid refine argument %s. It must be instance of SchemaNodeIdentifier.", refineArgument); + // FIXME: this really should be handled via separate inference, i.e. we first instantiate the template and when + // it appears, this refine will trigger on it. This reinforces the FIXME below. final Optional> optRefineTargetCtx = SchemaTreeNamespace.findNode( usesParentCtx, (SchemaNodeIdentifier) refineArgument); InferenceException.throwIf(!optRefineTargetCtx.isPresent(), subStmtCtx, "Refine target node %s not found.", @@ -311,33 +315,34 @@ public final class UsesStatementSupport subStmtCtx.coerceParentContext().argument(), refineTargetNodeCtx.argument(), subStmtCtx.sourceReference()); } else { - verify(refineTargetNodeCtx instanceof StatementContextBase); - addOrReplaceNodes(subStmtCtx, (StatementContextBase) refineTargetNodeCtx); + verify(refineTargetNodeCtx instanceof Mutable, "Unexpected target %s", refineTargetNodeCtx); + addOrReplaceNodes(subStmtCtx, (Mutable) refineTargetNodeCtx); } // Target is a prerequisite for the 'refine', hence if the target is not supported, the refine is not supported // as well. Otherwise add a pointer to the target into refine's local namespace. if (refineTargetNodeCtx.isSupportedToBuildEffective()) { - subStmtCtx.addToNs(RefineTargetNamespace.class, Empty.getInstance(), refineTargetNodeCtx); + subStmtCtx.addToNs(RefineTargetNamespace.class, Empty.value(), refineTargetNodeCtx); } else { - subStmtCtx.setIsSupportedToBuildEffective(false); + subStmtCtx.setUnsupported(); } } - private static void addOrReplaceNodes(final Mutable subStmtCtx, - final StatementContextBase refineTargetNodeCtx) { - for (final Mutable refineSubstatementCtx : subStmtCtx.mutableDeclaredSubstatements()) { + private static void addOrReplaceNodes(final StmtContext subStmtCtx, + final Mutable refineTargetNodeCtx) { + for (StmtContext refineSubstatementCtx : subStmtCtx.declaredSubstatements()) { if (isSupportedRefineSubstatement(refineSubstatementCtx)) { addOrReplaceNode(refineSubstatementCtx, refineTargetNodeCtx); } } } - private static void addOrReplaceNode(final Mutable refineSubstatementCtx, - final StatementContextBase refineTargetNodeCtx) { + private static void addOrReplaceNode(final StmtContext refineSubstatementCtx, + final Mutable refineTargetNodeCtx) { final StatementDefinition refineSubstatementDef = refineSubstatementCtx.publicDefinition(); + // FIXME: this is quite costly, use an explicit block SourceException.throwIf(!isSupportedRefineTarget(refineSubstatementCtx, refineTargetNodeCtx), refineSubstatementCtx, "Error in module '%s' in the refine of uses '%s': can not perform refine of '%s' for the target '%s'.", @@ -347,6 +352,7 @@ public final class UsesStatementSupport if (!isAllowedToAddByRefine(refineSubstatementDef)) { refineTargetNodeCtx.removeStatementFromEffectiveSubstatements(refineSubstatementDef); } + // FIXME: childCopyOf() should handle this through per-statement copy policy, right? refineTargetNodeCtx.addEffectiveSubstatement(refineSubstatementCtx.replicaAsChildOf(refineTargetNodeCtx)); }