case parse.NodeIf:
		out.Merge(getParams(n.(*parse.IfNode).Pipe))
	case parse.NodeWith:
		out.Merge(getParams(n.(*parse.WithNode).Pipe))
	case parse.NodeRange:
		out.Merge(getParams(n.(*parse.RangeNode).Pipe))
	case parse.NodeAction:
		out.Merge(getParams(n.(*parse.ActionNode).Pipe))
	case parse.NodeCommand:
		for _, arg := range n.(*parse.CommandNode).Args {
			out.Merge(getParams(arg))
		}
	case parse.NodePipe:

            public abstract class SomeTask extends DefaultTask {
                @Nested
                public abstract Params getParams();

                @TaskAction
                public void run() {
                    System.out.println("flag = " + getParams().getFlag().get());
                }
            }
        """
    }

            import ${Inject.name};

            public class SomeTask extends DefaultTask {
                private final Params params;

                @Nested
                public Params getParams() {
                    return params;
                }

                @Inject
                public SomeTask(ObjectFactory objectFactory) {
                    params = objectFactory.newInstance(Params.class);

            public abstract class ProducerTask extends DefaultTask {
                @Nested
                public abstract Params getParams();

                @TaskAction
                public void run() throws IOException {
                    Files.write(getParams().getOutFile().get().getAsFile().toPath(), "content".getBytes());
                }
            }
        """
    }

    public void params(Object... params) {
        Collections.addAll(this.params, params);
    }

    @Override
    public void setParams(Object... params) {
        this.params.clear();
        Collections.addAll(this.params, params);
    }

    @Override
    public Object[] getParams() {
        return this.params.toArray();
    }

            import ${TaskAction.name}
            import ${Nested.name}

            abstract class ProducerTask extends DefaultTask {
                @Nested
                abstract Params getParams()

                @TaskAction
                def run() {
                    params.outFile.get().asFile.text = "content"
                }
            }
        """
    }

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.getTasks().register("producer", ProducerTask.class, t -> {
                        t.getParams().getOutFile().set(project.getLayout().getBuildDirectory().file("intermediate.txt"));
                    });
                }
            }
        """
        pluginDir.file("src/main/java/Params.java") << """

            public class ProducerTask extends DefaultTask {
                private final Params params = getProject().getObjects().newInstance(Params.class);

                @Nested
                public Params getParams() {
                    return params;
                }

                @TaskAction
                public void run() throws IOException {

     *
     * @param params - the parameters to use during construction
     */
    void setParams(Object... params);

    /**
     * Gets the initialization parameters that will be used when constructing an instance of the implementation class.
     *
     * @return the parameters to use during construction
     */
    Object[] getParams();

                @Input
                Property<Integer> getCount()
            }
            abstract class MyTask extends DefaultTask {
                @Nested
                abstract Params getParams()

                @TaskAction
                void go() {
                    println("count = \${params.count.get()}")
                }
            }

            tasks.create("thing", MyTask) {