Migrate coerceStatementArgument() callers

[yangtools.git] / yang / yang-parser-rfc7950 / src / main / java / org / opendaylight / yangtools / yang / parser / rfc7950 / stmt / typedef / TypedefStatementSupport.java

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/typedef/TypedefStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/typedef/TypedefStatementSupport.java
index 2a3f25a888d6b39e4997e05b89467e60e3237728..b792eac6a0ce9c80ea0807fff7f36b4072d7aa78 100644 (file)
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/typedef/TypedefStatementSupport.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/typedef/TypedefStatementSupport.java
@@ -7,6 +7,8 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef;
 
+import static com.google.common.base.Preconditions.checkState;
+
 import com.google.common.collect.ImmutableList;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.Status;
@@ -22,6 +24,7 @@ import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSup
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
 import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
 import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
@@ -64,7 +67,7 @@ public final class TypedefStatementSupport extends
                 // Shadowing check: make sure we do not trample on pre-existing definitions. This catches sibling
                 // declarations and parent declarations which have already been declared.
                 checkConflict(parent, stmt);
-                parent.addContext(TypeNamespace.class, stmt.coerceStatementArgument(), stmt);
+                parent.addContext(TypeNamespace.class, stmt.getArgument(), stmt);
             }
         }
     }
@@ -78,45 +81,38 @@ public final class TypedefStatementSupport extends
     protected TypedefStatement createDeclared(final StmtContext<QName, TypedefStatement, ?> ctx,
             final ImmutableList<? extends DeclaredStatement<?>> substatements) {
         checkDeclared(ctx);
-        return new RegularTypedefStatement(ctx.coerceStatementArgument(), substatements);
+        return new RegularTypedefStatement(ctx.getArgument(), substatements);
     }
 
     @Override
     protected TypedefStatement createEmptyDeclared(final StmtContext<QName, TypedefStatement, ?> ctx) {
         checkDeclared(ctx);
-        return new EmptyTypedefStatement(ctx.coerceStatementArgument());
+        return new EmptyTypedefStatement(ctx.getArgument());
     }
 
     @Override
-    protected TypedefEffectiveStatement createEffective(
-            final StmtContext<QName, TypedefStatement, TypedefEffectiveStatement> ctx,
-            final TypedefStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+    protected TypedefEffectiveStatement createEffective(final Current<QName, TypedefStatement> stmt,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        final TypedefStatement declared = stmt.declared();
+        checkState(!substatements.isEmpty(), "Refusing to create empty typedef for %s", stmt.declared());
+
         final TypeEffectiveStatement<?> typeEffectiveStmt = findFirstStatement(substatements,
             TypeEffectiveStatement.class);
         final String dflt = findFirstArgument(substatements, DefaultEffectiveStatement.class, null);
         SourceException.throwIf(
-            EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(ctx.getRootVersion(), typeEffectiveStmt, dflt),
-            ctx.getStatementSourceReference(),
-            "Typedef '%s' has default value '%s' marked with an if-feature statement.", ctx.getStatementArgument(),
-            dflt);
+            EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(stmt.yangVersion(), typeEffectiveStmt, dflt),
+            stmt.sourceReference(),
+            "Typedef '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
 
-        return new TypedefEffectiveStatementImpl(declared, ctx.getSchemaPath().get(), computeFlags(substatements),
+        return new TypedefEffectiveStatementImpl(declared, stmt.getSchemaPath(), computeFlags(substatements),
             substatements);
     }
 
-    @Override
-    protected TypedefEffectiveStatement createEmptyEffective(
-            final StmtContext<QName, TypedefStatement, TypedefEffectiveStatement> ctx,
-            final TypedefStatement declared) {
-        throw new IllegalStateException("Refusing to create empty typedef for " + declared);
-    }
-
     private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) {
-        final QName arg = stmt.coerceStatementArgument();
+        final QName arg = stmt.getArgument();
         final StmtContext<?, ?, ?> existing = parent.getFromNamespace(TypeNamespace.class, arg);
         // RFC7950 sections 5.5 and 6.2.1: identifiers must not be shadowed
-        SourceException.throwIf(existing != null, stmt.getStatementSourceReference(), "Duplicate name for typedef %s",
-                arg);
+        SourceException.throwIf(existing != null, stmt.sourceReference(), "Duplicate name for typedef %s", arg);
     }
 
     private static void checkDeclared(final StmtContext<QName, TypedefStatement, ?> ctx) {