import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class FormattingValidationProblemCollector implements ValidationProblemCollector {
    private final String role;
    private final ModelType<?> source;
    private final List<String> problems = new ArrayList<String>();

    public FormattingValidationProblemCollector(String role, ModelType<?> source) {
        this.role = role;
        this.source = source;

class FormattingValidationProblemCollectorTest extends Specification {
    def "formats message with a single problem"() {
        given:
        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add("does not extend RuleSource")

        expect:
        collector.format() == 'Type java.lang.String is not a valid <thing>: does not extend RuleSource'

 * limitations under the License.
 */

package org.gradle.model.internal.manage.schema.extract;

import org.gradle.api.Action;
import org.gradle.internal.Actions;
import org.gradle.model.internal.inspect.FormattingValidationProblemCollector;
import org.gradle.model.internal.manage.schema.ModelSchema;
import org.gradle.model.internal.type.ModelType;

import javax.annotation.Nullable;
import java.lang.reflect.Constructor;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.manage.binding;

import org.gradle.model.internal.inspect.FormattingValidationProblemCollector;
import org.gradle.model.internal.manage.schema.StructSchema;
import org.gradle.model.internal.method.WeaklyTypeReferencingMethod;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

        List<Method> mutateMethods = findAllMethods(ruleSourceType.getConcreteClass(), element -> element.isAnnotationPresent(Mutate.class));
        FormattingValidationProblemCollector problemsFormatter = new FormattingValidationProblemCollector("rule source", ruleSourceType);
        RuleSourceValidationProblemCollector problems = new DefaultRuleSourceValidationProblemCollector(problemsFormatter);

import org.gradle.model.internal.inspect.DefaultModelRuleInvoker
import org.gradle.model.internal.inspect.ExtractedModelRule
import org.gradle.model.internal.inspect.FormattingValidationProblemCollector
import org.gradle.model.internal.inspect.MethodModelRuleApplicationContext
import org.gradle.model.internal.inspect.MethodRuleAction
import org.gradle.model.internal.inspect.MethodRuleDefinition

            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    private void validate(Class<?> publicClass) {
        FormattingValidationProblemCollector problemCollector = new FormattingValidationProblemCollector("Named implementation class", ModelType.of(publicClass));
        visitFields(publicClass, problemCollector);
        if (problemCollector.hasProblems()) {

        }
    }

    private <T> CachedRuleSource doExtract(final Class<T> source) {
        final ModelType<T> type = ModelType.of(source);
        FormattingValidationProblemCollector problems = new FormattingValidationProblemCollector("rule source", type);
        DefaultMethodModelRuleExtractionContext context = new DefaultMethodModelRuleExtractionContext(this, problems);

Class <org.gradle.model.internal.inspect.FormattingValidationProblemCollector> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (FormattingValidationProblemCollector.java:0)