import java.util.List;

public interface ExtractedModelRule {
    void apply(MethodModelRuleApplicationContext context, MutableModelNode target);

    List<? extends Class<?>> getRuleDependencies();

    MethodRuleDefinition<?, ?> getRuleDefinition();

            RuleExtractorUtils.configureRuleAction(context, ruleApplicationScope, mutationType, ruleAction);
        }

        @Override
        public List<? extends Class<?>> getRuleDependencies() {
            return Collections.emptyList();
        }
    }

            RuleExtractorUtils.configureRuleAction(context, ruleApplicationScope, ModelActionRole.Defaults, ruleAction);
        }

        @Override
        public List<? extends Class<?>> getRuleDependencies() {
            return Collections.emptyList();
        }
    }

    private static class RuleSourceApplicationAction implements MethodRuleAction {
        private final ModelReference<?> targetReference;

            registration.hidden(hidden);

            context.getRegistry().register(registration.build());
        }

        @Override
        public List<Class<?>> getRuleDependencies() {
            return Collections.emptyList();
        }

        @Override
        public MethodRuleDefinition<R, S> getRuleDefinition() {
            return Cast.uncheckedCast(super.getRuleDefinition());

            RuleExtractorUtils.configureRuleAction(context, RuleApplicationScope.DESCENDANTS, ModelActionRole.Finalize, componentBinariesRule);
        }

        @Override
        public List<? extends Class<?>> getRuleDependencies() {
            return ImmutableList.of(ComponentModelBasePlugin.class);
        }
    }

            for (ExtractedRuleDetails details : rules) {
                plugins.addAll(details.rule.getRuleDependencies());
            }
            return plugins;
        }

        @Override
        public void assertNoPlugins() {
            for (ExtractedRuleDetails details : rules) {
                if (!details.rule.getRuleDependencies().isEmpty()) {
                    StringBuilder message = new StringBuilder();

                @Override
                void apply(MethodModelRuleApplicationContext applicationContext, MutableModelNode target) {
                }

                @Override
                List<? extends Class<?>> getRuleDependencies() {
                    return [ImperativePlugin]
                }

                @Override
                MethodRuleDefinition<?, ?> getRuleDefinition() {
                    return ruleDefinition

                        }
                    }
            ));
        }

        @Override
        public List<? extends Class<?>> getRuleDependencies() {
            return ImmutableList.of(BinaryBasePlugin.class);
        }
    }

            super(ruleDefinition);
            this.info = info;
            this.modelType = modelType;
        }

        @Override
        public List<? extends Class<?>> getRuleDependencies() {
            return info.requiredPlugins;
        }

        @Override
        public void apply(final MethodModelRuleApplicationContext context, MutableModelNode target) {

        ruleExtractor.registration(_, _) >> { MethodRuleDefinition method, MethodModelRuleExtractionContext context ->
            return Stub(ExtractedModelRule) {
                getRuleDependencies() >> [method.getSubjectReference().getType().getConcreteClass()]
            }
        }

        expect:
        extractor.extract(RuleSourceWithDependencies).getRequiredPlugins() == [Long.class, String.class]