SimpleInterpretationSequenceStep(step.stepIdentifier, step.features) { analysisOnlySchema }
        }
    )

    override fun canBuild(modelName: String): Boolean =
        modelName == "org.gradle.declarative.dsl.tooling.models.DeclarativeSchemaModel"

    override fun buildAll(modelName: String, project: Project): Any {
        error("Model should be built before the configuration phase")
    }
}


private

        this.ideaModelBuilder = ideaModelBuilder;
    }

    @Override
    public boolean canBuild(String modelName) {
        return modelName.equals("org.gradle.tooling.model.idea.BasicIdeaProject");
    }

    @Override
    public DefaultIdeaProject buildAll(String modelName, Project project) {
        return ideaModelBuilder.buildForRoot(project, true);
    }

                    this.problemsService = problemsService
                }

                boolean canBuild(String modelName) {
                    return modelName == '${CustomModel.name}'
                }
                Object buildAll(String modelName, Project project) {
                    problemsService.${pre86api ? "create" : "forNamespace(\"org.example.plugin\").reporting"} {

        }

        @Override
        public Object fromBuildModel(BuildTreeModelController controller) {
            String modelName = buildModelAction.getModelName();
            ToolingModelScope scope = controller.locateBuilderForDefaultTarget(modelName, false);
            try {
                return scope.getModel(modelName, null);
            } catch (UnknownModelException e) {
                modelLookupFailure = e;
                throw e;

    CustomException(String msg) {
        super(msg)
    }
}

class CustomBuilder implements ToolingModelBuilder {
    boolean canBuild(String modelName) {
        return modelName == '${CustomModel.name}'
    }
    Object buildAll(String modelName, Project project) {
        throw ${'new RuntimeException(' * exceptionNestingLevel}new CustomException("Something went wrong in building the model")${')' * exceptionNestingLevel}

        private final String modelName;
        private final ModelType<? extends ComponentSpec> baseInterface;
        private final List<Class<?>> requiredPlugins;

        private ComponentTypeRegistrationInfo(String modelName, ModelType<? extends ComponentSpec> baseInterface, Class<?> requiredPlugins) {
            this.modelName = modelName;
            this.baseInterface = baseInterface;

class CustomModel implements Serializable {
    String value
}
class CustomBuilder implements ToolingModelBuilder {
    boolean canBuild(String modelName) {
        return modelName == 'org.gradle.integtests.tooling.r16.CustomModel'
    }
    Object buildAll(String modelName, Project project) {
        return new CustomModel(value: project.path)
    }
}
class CustomPlugin implements Plugin<Project> {
    @Inject

        String modelName = (annotationValue == null || annotationValue.isEmpty()) ? ruleDefinition.getMethodName() : annotationValue;

        try {
            ModelPath.validatePath(modelName);
        } catch (Exception e) {
            problems.add(ruleDefinition, "The declared model element path '" + modelName + "' is not a valid path", e);
        }

        }
        return buildDependencies;
    }

    @Override
    public boolean canBuild(String modelName) {
        return "org.gradle.tooling.model.eclipse.RunClosedProjectBuildDependencies".equals(modelName);
    }

    @Override
    public Object buildAll(String modelName, Project project) {
        // nothing to do if no EclipseRuntime is supplied.

            import org.gradle.api.Project

            class MyModelBuilder implements ToolingModelBuilder {
                boolean canBuild(String modelName) {
                    return modelName == "${List.class.name}"
                }
                Object buildAll(String modelName, Project project) {
                    println("creating model for \$project")
                    project.allprojects.each { p ->