Cannot access binary.args, why?

buildFruits2.gradle

@Managed interface JuiceComponent extends GeneralComponentSpec { }
@Managed interface FruitLanguage extends LanguageSourceSet {}

@Managed
interface JuiceBinarySpec extends BinarySpec {
    List<String> getArgs()
    void setArgs(List<String> args)
}

class JuicerTask extends SourceTask {
    @Input
    List<String> args

    @TaskAction
    void makeJuice() {
        println('Juicy args: '+args)
    }
}

class Juicer extends DefaultTask {
    List<String> args
}

class JuicerRules extends RuleSource {
    @ComponentType void registerComponent(TypeBuilder<JuiceComponent> builder) { }
    @ComponentType void registerFruitLanguage(TypeBuilder<FruitLanguage> builder) { }
    @ComponentType void registerJuiceBinarySpec(TypeBuilder<JuiceBinarySpec> builder) { }

    @ComponentBinaries
    void generateJuiceBinaries(ModelMap<JuiceBinarySpec> binaries, GeneralComponentSpec component) {
        binaries.create("builtinJuicer");
    }

    @BinaryTasks
    void generateTasks(ModelMap<Task> tasks, final JuiceBinarySpec binary) {
        // Skip the internal built-in binary, this avoid the non-mutable exception
        if (binary.name == "builtinJuicer") return
        tasks.create("${binary.name}Juicer", Juicer) { task ->
            task.args = binary.getArgs()
        }
    }
}

apply plugin: JuicerRules

model {
    components {
        juiceComponent(JuiceComponent) {
            binaries {
                // Describe the distributions
                source(JuiceBinarySpec) {
                    args = ['a', 'b']
                }
            }
            sources {
                // Describe the sources
                juice(FruitLanguage) {
                    source {
                        srcDirs 'src/main/fruit'
                    }
                }
            }
        }
    }
}

Change the creation rule source(JuiceBinarySpec) to a mutation rule: juicer
And change the task creation to tasks.create("${binary.name}Juicer", JuicerTask).
Then it "works".

This is discussed on the gradle forums.

The final answer is that the the @BinaryTasks generateTask(...) method was being called TWICE. It is called a FIRST time for the binary defined internally:

@ComponentBinaries
void generateJuiceBinaries(ModelMap<JuiceBinarySpec> binaries, GeneralComponentSpec component) {
    binaries.create("builtinJuicer");
}

And it is being called a SECOND time for by the binary defined in the DSL:

model {
    components {
        juiceComponent(JuiceComponent) {
            binaries {
                source(JuiceBinarySpec) { // Called due to this line
...

So to avoid the non-mutable exception, the generateTask(...) method has to skip over the internal binary:

@BinaryTasks
void generateTasks(ModelMap<Task> tasks, final JuiceBinarySpec binary) {
    if (binary.name == "builtinJuicer") return
    tasks.create("${binary.name}Juicer", Juicer) { task ->
        task.args = binary.getArgs()
    }
}

It still feels strange to have an exception thrown when a non-mutable is only being read (reading it should not change it).