ModelType<R> getReturnType();

    List<ModelReference<?>> getReferences();

    List<List<Annotation>> getParameterAnnotations();

    @Nullable
    ModelReference<S> getSubjectReference();

    List<ModelReference<?>> getTailReferences();

    ModelRuleDescriptor getDescriptor();

            MethodRuleDefinition<?, S> ruleDefinition = Cast.uncheckedCast(getRuleDefinition());
            MethodBackedModelAction<S> ruleAction = new MethodBackedModelAction<S>(ruleDefinition.getDescriptor(), ruleDefinition.getSubjectReference(), ruleDefinition.getTailReferences());
            RuleExtractorUtils.configureRuleAction(context, ruleApplicationScope, mutationType, ruleAction);
        }

        @Override

            problems.add(ruleDefinition, "A method " + getDescription() + " must have at least two parameters.");
            return;
        }

        ModelType<?> subjectType = ruleDefinition.getSubjectReference().getType();
        if (!isModelMap(subjectType)) {
            problems.add(ruleDefinition, String.format("The first parameter of a method %s must be of type %s.", getDescription(), ModelMap.class.getName()));

        return method.getName();
    }

    @Override
    public ModelType<R> getReturnType() {
        return method.getReturnType();
    }

    @Nullable
    @Override
    public ModelReference<S> getSubjectReference() {
        return Cast.uncheckedCast(references.isEmpty() ? null : references.get(0));
    }

    @Override
    public List<ModelReference<?>> getTailReferences() {

        }
    }

    @Override
    protected <R, S> ExtractedModelRule buildRule(ModelPath modelPath, MethodRuleDefinition<R, S> ruleDefinition) {
        ModelType<S> modelType = ruleDefinition.getSubjectReference().getType();
        final ModelSchema<S> modelSchema = getModelSchema(modelType, ruleDefinition);
        return new ExtractedManagedCreationRule<R, S>(modelPath, ruleDefinition, modelSchema);
    }

            return null;
        }

        ModelReference<?> subjectReference = ruleDefinition.getSubjectReference();
        ModelType<?> subjectType = subjectReference.getType();
        Class<?> rawSubjectType = subjectType.getRawClass();
        if (!rawSubjectType.equals(TypeBuilder.class)) {

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

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