From: Robert Varga Date: Wed, 1 Jul 2020 14:54:36 +0000 (+0200) Subject: Convert pattern statement X-Git-Tag: v5.0.4~54 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=ed04cedfbb0da198a7fd56c86a981bbefcec8dee;p=yangtools.git Convert pattern statement Convert the mostly trivial case of pattern statement, which can be easily minimized. We also terminally-deprecate AbstractConstraintEffectiveStatement, as it is no longer needed. JIRA: YANGTOOLS-1065 Change-Id: Ib207d3389959822635578733ef09607fe3f2373a Signed-off-by: Robert Varga --- diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java index 9f1c904998..31af61d5c7 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java @@ -8,10 +8,15 @@ package org.opendaylight.yangtools.yang.model.api.stmt; import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; @Beta public interface PatternEffectiveStatement extends EffectiveStatement { - + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.PATTERN; + } } diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java index b147685742..7ce9bd73fb 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java @@ -12,9 +12,16 @@ import static com.google.common.base.Verify.verifyNotNull; import java.util.Optional; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; public interface PatternStatement extends ConstrainedDocumentedDeclaredStatement { + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.PATTERN; + } + default @NonNull PatternConstraint getValue() { // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here return verifyNotNull(argument()); diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractConstraintEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractConstraintEffectiveStatement.java index 7fd7c36bff..12a3e56ee0 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractConstraintEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractConstraintEffectiveStatement.java @@ -19,6 +19,8 @@ import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @Beta +@Deprecated(forRemoval = true) +//FIXME: 6.0.0: remove this class public abstract class AbstractConstraintEffectiveStatement> extends AbstractEffectiveDocumentedNode implements ConstraintMetaDefinition { private final String errorAppTag; diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java index 8f1a7446d7..d7dd37dbf4 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java @@ -209,6 +209,43 @@ public abstract class AbstractDeclaredEffectiveStatement Argument type ({@link Void} if statement does not have argument.) + * @param Class representing declared version of this statement. + */ + public abstract static class DefaultWithArgument> extends Default { + public abstract static class WithSubstatements> + extends DefaultWithArgument { + private final @NonNull Object substatements; + + protected WithSubstatements(final D declared, final A argument, + final ImmutableList> substatements) { + super(declared, argument); + this.substatements = maskList(substatements); + } + + @Override + public final ImmutableList> effectiveSubstatements() { + return unmaskList(substatements); + } + } + + private final A argument; + + protected DefaultWithArgument(final D declared, final A argument) { + super(declared); + this.argument = argument; + } + + @Override + public final A argument() { + return argument; + } + } + /** * Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked). * diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java index c86acbf641..2c3b487039 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java @@ -7,21 +7,29 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; -import java.util.Optional; +import com.google.common.collect.ImmutableList; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; import org.opendaylight.yangtools.yang.model.util.RegexUtils; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; abstract class AbstractPatternStatementSupport - extends AbstractStatementSupport { + extends BaseStatementSupport { private static final Logger LOG = LoggerFactory.getLogger(AbstractPatternStatementSupport.class); AbstractPatternStatementSupport() { @@ -39,17 +47,45 @@ abstract class AbstractPatternStatementSupport return null; } - return new PatternConstraintImpl(pattern, value, Optional.empty(), Optional.empty()); + return new PatternConstraintImpl(pattern, value); } @Override - public final PatternStatement createDeclared(final StmtContext ctx) { - return new PatternStatementImpl(ctx); + protected final PatternStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularPatternStatement(ctx, substatements); } @Override - public final PatternEffectiveStatement createEffective( - final StmtContext ctx) { - return new PatternEffectiveStatementImpl(ctx); + protected final PatternStatement createEmptyDeclared( + final StmtContext ctx) { + return new EmptyPatternStatement(ctx); } -} \ No newline at end of file + + @Override + protected final PatternEffectiveStatement createEffective( + final StmtContext ctx, + final PatternStatement declared, final ImmutableList> substatements) { + final String description = findFirstArgument(substatements, DescriptionEffectiveStatement.class, null); + final String reference = findFirstArgument(substatements, ReferenceEffectiveStatement.class, null); + final String errorAppTag = findFirstArgument(substatements, ErrorAppTagEffectiveStatement.class, null); + final String errorMessage = findFirstArgument(substatements, ErrorMessageEffectiveStatement.class, null); + final ModifierKind modifier = findFirstArgument(substatements, ModifierEffectiveStatement.class, null); + + if (description == null && reference == null && errorAppTag == null && errorMessage == null + && modifier == null) { + // No customization, just use declared statement for the actual value + return new SimplePatternEffectiveStatement(declared, substatements); + } + + return new RegularPatternEffectiveStatement(declared, new PatternConstraintImpl(declared.argument(), + description, reference, errorAppTag, errorMessage, modifier), substatements); + } + + @Override + protected final PatternEffectiveStatement createEmptyEffective( + final StmtContext ctx, + final PatternStatement declared) { + return new EmptyPatternEffectiveStatement(declared); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternEffectiveStatement.java new file mode 100644 index 0000000000..368f353d17 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternEffectiveStatement.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; + +import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement; +import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.ConstraintMetaDefinitionMixin; + +final class EmptyPatternEffectiveStatement extends DefaultArgument + implements PatternEffectiveStatement, ConstraintMetaDefinitionMixin { + EmptyPatternEffectiveStatement(final PatternStatement declared) { + super(declared); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternStatement.java similarity index 59% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternStatementImpl.java rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternStatement.java index 27f8aa2d30..d4898e066a 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, @@ -9,11 +9,11 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithArgument; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -public class PatternStatementImpl extends AbstractDeclaredStatement implements PatternStatement { - protected PatternStatementImpl(final StmtContext context) { +final class EmptyPatternStatement extends WithArgument implements PatternStatement { + EmptyPatternStatement(final StmtContext context) { super(context); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java index 2bb4fef2a6..9020579d55 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java @@ -17,7 +17,6 @@ import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; final class PatternConstraintImpl implements PatternConstraint, Immutable { - private final String regEx; private final String rawRegEx; private final String description; @@ -26,12 +25,7 @@ final class PatternConstraintImpl implements PatternConstraint, Immutable { private final String errorMessage; private final ModifierKind modifier; - PatternConstraintImpl(final String regex, final String rawRegex, - final Optional description, final Optional reference) { - this(regex, rawRegex, description.orElse(null), reference.orElse(null), null, null, null); - } - - PatternConstraintImpl(final String regex, final String rawRegex, final String description, + private PatternConstraintImpl(final String regex, final String rawRegex, final String description, final String reference, final String errorAppTag, final String errorMessage, final ModifierKind modifier) { this.regEx = requireNonNull(regex, "regex must not be null"); this.rawRegEx = requireNonNull(rawRegex, "raw regex must not be null"); @@ -42,6 +36,16 @@ final class PatternConstraintImpl implements PatternConstraint, Immutable { this.modifier = modifier; } + PatternConstraintImpl(final String regex, final String rawRegex) { + this(regex, rawRegex, null, null, null, null, null); + } + + PatternConstraintImpl(final PatternConstraint original, final String description, final String reference, + final String errorAppTag, final String errorMessage, final ModifierKind modifier) { + this(original.getJavaPatternString(), original.getRegularExpressionString(), description, reference, + errorAppTag, errorMessage, modifier); + } + @Override public String getJavaPatternString() { return regEx; diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternEffectiveStatementImpl.java deleted file mode 100644 index 747fb8d23e..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternEffectiveStatementImpl.java +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; - -import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement; -import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractConstraintEffectiveStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; - -final class PatternEffectiveStatementImpl - extends AbstractConstraintEffectiveStatement - implements PatternEffectiveStatement { - PatternEffectiveStatementImpl(final StmtContext ctx) { - super(ctx); - } - - @Override - protected PatternConstraint createConstraints(final PatternConstraint argument) { - if (!isCustomizedStatement()) { - return argument; - } - - return new PatternConstraintImpl(argument.getJavaPatternString(), - argument.getRegularExpressionString(), - getDescription().orElse(null), getReference().orElse(null), getErrorAppTag().orElse(null), - getErrorMessage().orElse(null), getModifier()); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternEffectiveStatement.java new file mode 100644 index 0000000000..d13d8e4f3c --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternEffectiveStatement.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; + +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement; +import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithArgument.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.ConstraintMetaDefinitionMixin; + +final class RegularPatternEffectiveStatement extends WithSubstatements + implements PatternEffectiveStatement, ConstraintMetaDefinitionMixin { + RegularPatternEffectiveStatement(final PatternStatement declared, final PatternConstraint argument, + final ImmutableList> substatements) { + super(declared, argument, substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternStatement.java new file mode 100644 index 0000000000..196de30144 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternStatement.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; + +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement; +import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithArgument.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class RegularPatternStatement extends WithSubstatements implements PatternStatement { + RegularPatternStatement(final StmtContext context, + final ImmutableList> substatements) { + super(context, substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/SimplePatternEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/SimplePatternEffectiveStatement.java new file mode 100644 index 0000000000..1ae51f0e5f --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/SimplePatternEffectiveStatement.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; + +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement; +import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.ConstraintMetaDefinitionMixin; + +final class SimplePatternEffectiveStatement extends WithSubstatements + implements PatternEffectiveStatement, ConstraintMetaDefinitionMixin { + + SimplePatternEffectiveStatement(final PatternStatement declared, + final ImmutableList> substatements) { + super(declared, substatements); + } +}