bracket(
            optional(
                expression * zeroOrMore(token(COMMA) * expression) * optional(token(COMMA))
            )
        )

    val parenthesizedType by debug {
        paren(type)
    }

    val parenthesizedExpression by debug {
        paren(expression)
    }

    val valueArgument by debug {

                }
            }
            if (isScalarType(getType())) {
                return Optional.of("null");
            }
            return Optional.absent();
        }
        if (hasDefaultToString(instance)) {
            return Optional.absent();
        }
        return Optional.of(toStringValueDescription(instance));
    }

import com.google.common.base.Optional;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.model.internal.manage.binding.ManagedProperty;
import org.gradle.model.internal.type.ModelType;

public class NodeInitializerContext<T> {
    private final ModelType<T> modelType;
    private final Spec<ModelType<?>> constraints;
    private final Optional<PropertyContext> propertyContextOptional;

        );
    }


    private static Optional<String> getUnsupportedReason(Class<?> type) {
        if (type.getName().startsWith("java.") || type.getName().startsWith("javax.")) {
            return Optional.of("Type is in 'java.*' or 'javax.*' package that are reserved for standard Java API types");
        } else if (type.getName().startsWith("kotlin.")) {

import javax.annotation.Nullable;
import java.util.Optional;
import java.util.function.Supplier;

abstract public class ProblemRecordingTypeValidationContext implements TypeValidationContext {
    private final Class<?> rootType;
    private final Supplier<Optional<PluginId>> pluginId;

    public ProblemRecordingTypeValidationContext(
        @Nullable Class<?> rootType,
        Supplier<Optional<PluginId>> pluginId
    ) {

    default void visitInputFileProperty(String propertyName, boolean optional, InputBehavior behavior, DirectorySensitivity directorySensitivity, LineEndingSensitivity lineEndingSensitivity, @Nullable FileNormalizer fileNormalizer, PropertyValue value, InputFilePropertyType filePropertyType) {}

    default void visitInputProperty(String propertyName, PropertyValue value, boolean optional) {}

        return InstanceModelView.of(modelNode.getPath(), getType(), null);
    }

    @Override
    public Optional<String> getValueDescription(MutableModelNode mutableModelNode) {
        return Optional.absent();
    }

            parameters,
            object : ProblemRecordingTypeValidationContext(type, { Optional.empty() }) {
                override fun recordProblem(problem: Problem) {
                    problems.add(problem)
                }
            },
            object : PropertyVisitor {

    }

    @Override
    public Optional<FileCollectionExecutionTimeValue> calculateExecutionTimeValue() {
        FileCollectionExecutionTimeValue executionTimeValue = displayName.equals(DEFAULT_COLLECTION_DISPLAY_NAME)
            ? EmptyExecutionTimeValue.INSTANCE
            : new EmptyExecutionTimeValue(displayName);

        return Optional.of(executionTimeValue);
    }

            if (view != null) {
                return view;
            }
        }
        return null;
    }

    @Override
    public Optional<String> getValueDescription(MutableModelNode modelNodeInternal) {
        for (ModelProjection projection : projections) {
            Optional<String> projectionValueDescription = projection.getValueDescription(modelNodeInternal);
            if (projectionValueDescription.isPresent()) {