Fix incorrect bitmask exposed by DeferredMemberSchema

The bitmask applies to the member, not its target schema -- delegating
to the target schema exposes the wrong bitmask.

Also fix an incidental similar issue in
requiredStructureMemberBitField(), though I haven't seen any negative
effects from the previous implementation of that one.

Author: rationull

core/src/main/java/software/amazon/smithy/java/core/schema/DeferredMemberSchema.java

@@ -15,11 +15,13 @@ final class DeferredMemberSchema extends Schema {
 
     private final SchemaBuilder target;
     private final TraitMap directTraits;
+    private final long requiredByValidationBitmask;
 
     DeferredMemberSchema(MemberSchemaBuilder builder) {
         super(builder);
         this.target = builder.targetBuilder;
         this.directTraits = builder.directTraits;
+        this.requiredByValidationBitmask = builder.requiredByValidationBitmask;
     }
 
     @Override
@@ -44,12 +46,21 @@ public int requiredMemberCount() {
 
     @Override
     long requiredByValidationBitmask() {
-        return memberTarget().requiredByValidationBitmask();
+        // The bitmask applies to the member itself, not its target schema, so this should not be forwarded
+        // to memberTarget as the previous accessors do.
+        return requiredByValidationBitmask;
     }
 
     @Override
     long requiredStructureMemberBitfield() {
-        return memberTarget().requiredStructureMemberBitfield();
+        // MemberSchema computes this at initialization time, but here we need to defer it
+        // until we can build the concrete target.
+        var target = memberTarget();
+        return SchemaBuilder.computeRequiredBitField(
+                type(),
+                target.requiredMemberCount(),
+                target.members(),
+                Schema::requiredByValidationBitmask);
     }
 
     @Override

core/src/main/java/software/amazon/smithy/java/core/schema/MemberSchema.java

@@ -26,7 +26,7 @@ final class MemberSchema extends Schema {
         this.requiredStructureMemberBitfield = SchemaBuilder.computeRequiredBitField(
                 type(),
                 target.requiredMemberCount(),
-                builder.target.members(),
+                target.members(),
                 Schema::requiredByValidationBitmask);
         this.requiredByValidationBitmask = builder.requiredByValidationBitmask;
     }

core/src/test/java/software/amazon/smithy/java/core/schema/ValidatorTest.java

@@ -131,6 +131,39 @@ public void detectsTooDeepRecursion() {
         assertThat(errors.get(0).path(), equalTo("/"));
     }
 
+    @Test
+    public void detectsPresenceForNestedRecursiveFields() {
+        var innerBuilder = Schema.structureBuilder(ShapeId.from("smithy.example#Inner"))
+                .putMember("foo", PreludeSchemas.STRING, new RequiredTrait());
+        var innerSchema = innerBuilder.build();
+
+        var innerInstance = TestHelper.create(innerSchema, (schema, serializer) -> {
+            serializer.writeString(schema.member("foo"), "bar");
+        });
+
+        var rootSchemaWithMember = Schema.structureBuilder(ShapeId.from("smithy.example#Root"))
+                .putMember("inner", innerSchema, new RequiredTrait())
+                .build();
+        var rootInstanceWithMember = TestHelper.create(rootSchemaWithMember, (schema, serializer) -> {
+            serializer.writeStruct(schema.member("inner"), innerInstance);
+        });
+
+        var rootSchemaWithDeferredMember = Schema.structureBuilder(ShapeId.from("smithy.example#Root"))
+                .putMember("inner", innerBuilder, new RequiredTrait())
+                .build();
+        var rootInstanceWithDeferredMember = TestHelper.create(rootSchemaWithDeferredMember, (schema, serializer) -> {
+            serializer.writeStruct(schema.member("inner"), innerInstance);
+        });
+
+        var validator = Validator.builder().build();
+
+        var memberErrors = validator.validate(rootInstanceWithMember);
+        assertThat(memberErrors, empty());
+
+        var deferredMemberErrors = validator.validate(rootInstanceWithDeferredMember);
+        assertThat(deferredMemberErrors, empty());
+    }
+
     private List<Schema> createListSchemas(int depth) {
         List<Schema> schemas = new ArrayList<>(depth);
         for (int i = depth; i > 0; i--) {