X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-rfc7950%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Frfc7950%2Fstmt%2Ftype%2FAbstractTypeStatementSupport.java;h=14d98bb86f3a1c3a74b8e6b3f1e88603e664bfd6;hb=7fd1abd03d792989653a05052e723b1516a9e554;hp=ebf7997f616811beda332d3ae47b9f68935ba079;hpb=608467c8b3e104dcd60c50d20c438f7cfd01631e;p=yangtools.git diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java index ebf7997f61..14d98bb86f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/type/AbstractTypeStatementSupport.java @@ -7,16 +7,18 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type; -import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Verify.verifyNotNull; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import com.google.common.collect.Maps; import java.math.BigDecimal; import java.util.Collection; import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.Empty; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; @@ -53,18 +55,19 @@ import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; -import org.opendaylight.yangtools.yang.model.util.type.BitsTypeBuilder; -import org.opendaylight.yangtools.yang.model.util.type.EnumerationTypeBuilder; -import org.opendaylight.yangtools.yang.model.util.type.InstanceIdentifierTypeBuilder; -import org.opendaylight.yangtools.yang.model.util.type.InvalidLengthConstraintException; -import org.opendaylight.yangtools.yang.model.util.type.InvalidRangeConstraintException; -import org.opendaylight.yangtools.yang.model.util.type.LengthRestrictedTypeBuilder; -import org.opendaylight.yangtools.yang.model.util.type.RangeRestrictedTypeBuilder; -import org.opendaylight.yangtools.yang.model.util.type.RequireInstanceRestrictedTypeBuilder; -import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes; -import org.opendaylight.yangtools.yang.model.util.type.StringTypeBuilder; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport; +import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.ri.type.BitsTypeBuilder; +import org.opendaylight.yangtools.yang.model.ri.type.EnumerationTypeBuilder; +import org.opendaylight.yangtools.yang.model.ri.type.InstanceIdentifierTypeBuilder; +import org.opendaylight.yangtools.yang.model.ri.type.InvalidLengthConstraintException; +import org.opendaylight.yangtools.yang.model.ri.type.InvalidRangeConstraintException; +import org.opendaylight.yangtools.yang.model.ri.type.LengthRestrictedTypeBuilder; +import org.opendaylight.yangtools.yang.model.ri.type.RangeRestrictedTypeBuilder; +import org.opendaylight.yangtools.yang.model.ri.type.RequireInstanceRestrictedTypeBuilder; +import org.opendaylight.yangtools.yang.model.ri.type.RestrictedTypes; +import org.opendaylight.yangtools.yang.model.ri.type.StringTypeBuilder; import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace; +import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; @@ -79,13 +82,9 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; abstract class AbstractTypeStatementSupport - extends BaseStatementSupport> { - private static final Logger LOG = LoggerFactory.getLogger(AbstractTypeStatementSupport.class); - + extends AbstractStringStatementSupport> { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder( YangStmtMapping.TYPE) .addOptional(YangStmtMapping.BASE) @@ -120,29 +119,26 @@ abstract class AbstractTypeStatementSupport static final String UINT64 = "uint64"; static final String UNION = "union"; - private static final ImmutableMap BUILT_IN_TYPES = ImmutableMap.builder() - .put(BINARY, BINARY) - .put(BITS, BITS) - .put(BOOLEAN, BOOLEAN) - .put(DECIMAL64, DECIMAL64) - .put(EMPTY, EMPTY) - .put(ENUMERATION, ENUMERATION) - .put(IDENTITY_REF,IDENTITY_REF) - .put(INSTANCE_IDENTIFIER, INSTANCE_IDENTIFIER) - .put(INT8, INT8) - .put(INT16, INT16) - .put(INT32, INT32) - .put(INT64, INT64) - .put(LEAF_REF, LEAF_REF) - .put(STRING, STRING) - .put(UINT8, UINT8) - .put(UINT16, UINT16) - .put(UINT32, UINT32) - .put(UINT64, UINT64) - .put(UNION, UNION) - .build(); + private static final ImmutableMap STATIC_BUILT_IN_TYPES = + ImmutableMap.builder() + .put(BINARY, BuiltinEffectiveStatement.BINARY) + .put(BOOLEAN, BuiltinEffectiveStatement.BOOLEAN) + .put(EMPTY, BuiltinEffectiveStatement.EMPTY) + // FIXME: this overlaps with DYNAMIC_BUILT_IN_TYPES. One of these is not needed, but we need to decide + // what to do. I think we should gradually use per-statement validators, hence go towards dynamic? + .put(INSTANCE_IDENTIFIER, BuiltinEffectiveStatement.INSTANCE_IDENTIFIER) + .put(INT8, BuiltinEffectiveStatement.INT8) + .put(INT16, BuiltinEffectiveStatement.INT16) + .put(INT32, BuiltinEffectiveStatement.INT32) + .put(INT64, BuiltinEffectiveStatement.INT64) + .put(STRING, BuiltinEffectiveStatement.STRING) + .put(UINT8, BuiltinEffectiveStatement.UINT8) + .put(UINT16, BuiltinEffectiveStatement.UINT16) + .put(UINT32, BuiltinEffectiveStatement.UINT32) + .put(UINT64, BuiltinEffectiveStatement.UINT64) + .build(); - private static final ImmutableMap> ARGUMENT_SPECIFIC_SUPPORTS = + private static final ImmutableMap> DYNAMIC_BUILT_IN_TYPES = ImmutableMap.>builder() .put(BITS, new BitsSpecificationSupport()) .put(DECIMAL64, new Decimal64SpecificationSupport()) @@ -153,13 +149,11 @@ abstract class AbstractTypeStatementSupport .put(UNION, new UnionSpecificationSupport()) .build(); - AbstractTypeStatementSupport() { - super(YangStmtMapping.TYPE); - } + private static final ImmutableMap BUILT_IN_TYPES = Maps.uniqueIndex(ImmutableSet.copyOf( + Iterables.concat(STATIC_BUILT_IN_TYPES.keySet(), DYNAMIC_BUILT_IN_TYPES.keySet())), key -> key); - @Override - public final String parseArgumentValue(final StmtContext ctx, final String value) { - return value; + AbstractTypeStatementSupport() { + super(YangStmtMapping.TYPE, StatementPolicy.exactReplica()); } @Override @@ -167,14 +161,14 @@ abstract class AbstractTypeStatementSupport final Mutable> stmt) { super.onFullDefinitionDeclared(stmt); - // if it is yang built-in type, no prerequisite is needed, so simply return - if (BUILT_IN_TYPES.containsKey(stmt.argument())) { - // FIXME: consider populating BaseTypeNamespace here, which could be done quite efficiently, moving the - // logic from resolveType() + final String argument = stmt.getArgument(); + final BuiltinEffectiveStatement builtin = STATIC_BUILT_IN_TYPES.get(argument); + if (builtin != null) { + stmt.addToNs(BaseTypeNamespace.class, Empty.getInstance(), builtin); return; } - final QName typeQName = StmtContextUtils.parseNodeIdentifier(stmt, stmt.argument()); + final QName typeQName = StmtContextUtils.parseNodeIdentifier(stmt, argument); final ModelActionBuilder typeAction = stmt.newInferenceAction(ModelProcessingPhase.EFFECTIVE_MODEL); final Prerequisite> typePrereq = typeAction.requiresCtx(stmt, TypeNamespace.class, typeQName, ModelProcessingPhase.EFFECTIVE_MODEL); @@ -187,6 +181,7 @@ abstract class AbstractTypeStatementSupport typeAction.apply(new InferenceAction() { @Override public void apply(final InferenceContext ctx) { + // Note: do not attempt to call buildEffective() here stmt.addToNs(BaseTypeNamespace.class, Empty.getInstance(), typePrereq.resolve(ctx)); } @@ -205,12 +200,12 @@ abstract class AbstractTypeStatementSupport @Override public boolean hasArgumentSpecificSupports() { - return !ARGUMENT_SPECIFIC_SUPPORTS.isEmpty(); + return !DYNAMIC_BUILT_IN_TYPES.isEmpty(); } @Override public StatementSupport getSupportSpecificForArgument(final String argument) { - return ARGUMENT_SPECIFIC_SUPPORTS.get(argument); + return DYNAMIC_BUILT_IN_TYPES.get(argument); } @Override @@ -221,14 +216,14 @@ abstract class AbstractTypeStatementSupport @Override protected final TypeStatement createDeclared(final StmtContext ctx, final ImmutableList> substatements) { - return new RegularTypeStatement(ctx.getRawArgument(), substatements); + return DeclaredStatements.createType(ctx.getRawArgument(), substatements); } @Override protected final TypeStatement createEmptyDeclared(final StmtContext ctx) { final TypeStatement builtin; return (builtin = BuiltinTypeStatement.lookup(ctx)) != null ? builtin - : new EmptyTypeStatement(ctx.getRawArgument()); + : DeclaredStatements.createType(ctx.getRawArgument()); } @Override @@ -261,32 +256,32 @@ abstract class AbstractTypeStatementSupport return createInstanceIdentifier(stmt, (InstanceIdentifierTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof Int8TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof Int16TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof Int32TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof Int64TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof LeafrefTypeDefinition) { return createLeafref(stmt, (LeafrefTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof StringTypeDefinition) { return createString(stmt, (StringTypeDefinition) baseType, declared, substatements); } else if (baseType instanceof Uint8TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof Uint16TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof Uint32TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof Uint64TypeDefinition) { return createIntegral(stmt, declared, substatements, - RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt))); + RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveQName(stmt))); } else if (baseType instanceof UnionTypeDefinition) { return createUnion(stmt, (UnionTypeDefinition) baseType, declared, substatements); } else { @@ -294,18 +289,16 @@ abstract class AbstractTypeStatementSupport } } - static final SchemaPath typeEffectiveSchemaPath(final Current stmt) { - final SchemaPath path = stmt.wrapSchemaPath(); - if (path == null) { - // SchemaPath is forbidden with a system property - return null; - } - final SchemaPath parent = path.getParent(); - final QName parentQName = parent.getLastComponent(); - checkArgument(parentQName != null, "Path %s has an empty parent", path); - - final QName qname = path.getLastComponent().bindTo(parentQName.getModule()).intern(); - return parent.createChild(qname); + // FIXME: YANGTOOLS-1208: this needs to happen during onFullDefinitionDeclared() and stored (again) in a namespace + static final @NonNull QName typeEffectiveQName(final Current stmt) { + // FIXME: YANGTOOLS-1117: this really should be handled through A=AbstractQName, with two values coming out of + // parseArgument(): either UnqualifiedQName or QualifiedQName. Each of those can easily be bound to + // parent module: + // stmt.getArgument().bindTo(parentNamespace). + final String argument = stmt.getArgument(); + return QName.create(stmt.getEffectiveParent().effectiveNamespace(), + // Split out localName event if it is prefixed. This should really be in parseArgument() + argument.substring(argument.indexOf(':') + 1)).intern(); } /** @@ -316,49 +309,22 @@ abstract class AbstractTypeStatementSupport * @throws SourceException if the target type cannot be found */ private static @NonNull TypeEffectiveStatement resolveType(final Current ctx) { - final StmtContext baseType = ctx.namespaceItem(BaseTypeNamespace.class, Empty.getInstance()); - if (baseType != null) { - return ((TypedefEffectiveStatement) baseType.buildEffective()).asTypeEffectiveStatement(); - } - - final String argument = ctx.getArgument(); - switch (argument) { - case BINARY: - return BuiltinEffectiveStatement.BINARY; - case BOOLEAN: - return BuiltinEffectiveStatement.BOOLEAN; - case EMPTY: - return BuiltinEffectiveStatement.EMPTY; - case INSTANCE_IDENTIFIER: - return BuiltinEffectiveStatement.INSTANCE_IDENTIFIER; - case INT8: - return BuiltinEffectiveStatement.INT8; - case INT16: - return BuiltinEffectiveStatement.INT16; - case INT32: - return BuiltinEffectiveStatement.INT32; - case INT64: - return BuiltinEffectiveStatement.INT64; - case STRING: - return BuiltinEffectiveStatement.STRING; - case UINT8: - return BuiltinEffectiveStatement.UINT8; - case UINT16: - return BuiltinEffectiveStatement.UINT16; - case UINT32: - return BuiltinEffectiveStatement.UINT32; - case UINT64: - return BuiltinEffectiveStatement.UINT64; - default: - throw new IllegalStateException("Unhandled type argument " + argument); + final Object obj = verifyNotNull(ctx.namespaceItem(BaseTypeNamespace.class, Empty.getInstance())); + if (obj instanceof BuiltinEffectiveStatement) { + return (BuiltinEffectiveStatement) obj; + } else if (obj instanceof StmtContext) { + return ((TypedefEffectiveStatement) ((StmtContext) obj).buildEffective()) + .asTypeEffectiveStatement(); + } else { + throw new InferenceException(ctx, "Unexpected base object %s", obj); } } - private static @NonNull TypeEffectiveStatement createBinary(final Current ctx, + private static @NonNull TypeEffectiveStatement createBinary(final Current ctx, final BinaryTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final LengthRestrictedTypeBuilder builder = - RestrictedTypes.newBinaryBuilder(baseType, typeEffectiveSchemaPath(ctx)); + RestrictedTypes.newBinaryBuilder(baseType, typeEffectiveQName(ctx)); for (EffectiveStatement stmt : substatements) { if (stmt instanceof LengthEffectiveStatement) { @@ -380,7 +346,7 @@ abstract class AbstractTypeStatementSupport private @NonNull TypeEffectiveStatement createBits(final Current ctx, final BitsTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { - final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.wrapSchemaPath()); + final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.argumentAsTypeQName()); for (final EffectiveStatement stmt : substatements) { if (stmt instanceof BitEffectiveStatement) { @@ -394,18 +360,18 @@ abstract class AbstractTypeStatementSupport abstract @NonNull Bit addRestrictedBit(@NonNull EffectiveStmtCtx stmt, @NonNull BitsTypeDefinition base, @NonNull BitEffectiveStatement bit); - private static @NonNull TypeEffectiveStatement createBoolean(final Current ctx, + private static @NonNull TypeEffectiveStatement createBoolean(final Current ctx, final BooleanTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newBooleanBuilder(baseType, - typeEffectiveSchemaPath(ctx))); + typeEffectiveQName(ctx))); } - private static @NonNull TypeEffectiveStatement createDecimal(final Current ctx, + private static @NonNull TypeEffectiveStatement createDecimal(final Current ctx, final DecimalTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final RangeRestrictedTypeBuilder builder = - RestrictedTypes.newDecima64Builder(baseType, typeEffectiveSchemaPath(ctx)); + RestrictedTypes.newDecima64Builder(baseType, typeEffectiveQName(ctx)); for (EffectiveStatement stmt : substatements) { if (stmt instanceof RangeEffectiveStatement) { @@ -422,17 +388,18 @@ abstract class AbstractTypeStatementSupport return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createEmpty(final Current ctx, + private static @NonNull TypeEffectiveStatement createEmpty(final Current ctx, final EmptyTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newEmptyBuilder(baseType, - typeEffectiveSchemaPath(ctx))); + typeEffectiveQName(ctx))); } private @NonNull TypeEffectiveStatement createEnum(final Current ctx, final EnumTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { - final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, ctx.wrapSchemaPath()); + final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, + ctx.argumentAsTypeQName()); for (final EffectiveStatement stmt : substatements) { if (stmt instanceof EnumEffectiveStatement) { @@ -446,18 +413,18 @@ abstract class AbstractTypeStatementSupport abstract @NonNull EnumPair addRestrictedEnum(@NonNull EffectiveStmtCtx stmt, @NonNull EnumTypeDefinition base, @NonNull EnumEffectiveStatement enumStmt); - private static @NonNull TypeEffectiveStatement createIdentityref(final Current ctx, + private static @NonNull TypeEffectiveStatement createIdentityref(final Current ctx, final IdentityrefTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newIdentityrefBuilder(baseType, - typeEffectiveSchemaPath(ctx))); + typeEffectiveQName(ctx))); } - private static @NonNull TypeEffectiveStatement createInstanceIdentifier( - final Current ctx, final InstanceIdentifierTypeDefinition baseType, final TypeStatement declared, + private static @NonNull TypeEffectiveStatement createInstanceIdentifier(final Current ctx, + final InstanceIdentifierTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(baseType, - typeEffectiveSchemaPath(ctx)); + typeEffectiveQName(ctx)); for (EffectiveStatement stmt : substatements) { if (stmt instanceof RequireInstanceEffectiveStatement) { @@ -486,11 +453,11 @@ abstract class AbstractTypeStatementSupport } } - private static @NonNull TypeEffectiveStatement createLeafref(final Current ctx, + private static @NonNull TypeEffectiveStatement createLeafref(final Current ctx, final LeafrefTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final RequireInstanceRestrictedTypeBuilder builder = - RestrictedTypes.newLeafrefBuilder(baseType, AbstractTypeStatementSupport.typeEffectiveSchemaPath(ctx)); + RestrictedTypes.newLeafrefBuilder(baseType, AbstractTypeStatementSupport.typeEffectiveQName(ctx)); for (final EffectiveStatement stmt : substatements) { if (stmt instanceof RequireInstanceEffectiveStatement) { @@ -500,11 +467,11 @@ abstract class AbstractTypeStatementSupport return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createString(final Current ctx, + private static @NonNull TypeEffectiveStatement createString(final Current ctx, final StringTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { final StringTypeBuilder builder = RestrictedTypes.newStringBuilder(baseType, - AbstractTypeStatementSupport.typeEffectiveSchemaPath(ctx)); + AbstractTypeStatementSupport.typeEffectiveQName(ctx)); for (EffectiveStatement stmt : substatements) { if (stmt instanceof LengthEffectiveStatement) { @@ -526,10 +493,10 @@ abstract class AbstractTypeStatementSupport return new TypeEffectiveStatementImpl<>(declared, substatements, builder); } - private static @NonNull TypeEffectiveStatement createUnion(final Current ctx, + private static @NonNull TypeEffectiveStatement createUnion(final Current ctx, final UnionTypeDefinition baseType, final TypeStatement declared, final ImmutableList> substatements) { return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newUnionBuilder(baseType, - typeEffectiveSchemaPath(ctx))); + typeEffectiveQName(ctx))); } } \ No newline at end of file