package org.gradle.language.base.internal;

import org.gradle.api.Task;
import org.gradle.language.base.LanguageSourceSet;

public interface JointCompileTaskConfig extends SourceTransformTaskConfig {
    boolean canTransform(LanguageSourceSet candidate);

    void configureAdditionalTransform(Task task, LanguageSourceSet sourceSet);

     */
    Object[] transform(CachedClass[] types, Object[] args);

    /*
     * Returns Whether the transformer can transform
     * these arguments at all.
     */
    boolean canTransform(Object[] args);

            } else {
                transformed[i] = args[i];
            }
        }
        return transformed;
    }

    @Override
    public boolean canTransform(Object[] args) {
        for (Object arg : args) {
            if (arg instanceof CharSequence) {
                return true;
            }
        }
        return false;
    }

    @Override

                    while (candidateSourceSets.hasNext()) {
                        LanguageSourceSetInternal candidate = candidateSourceSets.next();
                        if (jointCompileTaskConfig.canTransform(candidate)) {
                            jointCompileTaskConfig.configureAdditionalTransform(task, candidate);
                            candidateSourceSets.remove();
                        }
                    }

            if (metaMethod != null) {
                return DynamicInvokeResult.found(metaMethod.doMethodInvoke(bean, arguments));
            }

            if (argsTransformer.canTransform(arguments)) {
                List<MetaMethod> metaMethods = metaClass.respondsTo(bean, name);
                for (MetaMethod method : metaMethods) {

                if (!types[i].theClass.isInstance(result[i])) {
                    return args
                }
            }
            return result
        }

        @Override
        boolean canTransform(Object[] args) {
            return true
        }
    }

    static class Bean {
        String prop

        String m(int l) {
            return "[${l + 1}]"
        }

// functional ops. A trivial transformation can be done when the regions are
// just calls to functions, in which case no outlining is needed.
struct TrivialTransformInfo {
  // Can the op be transformed trivially?
  bool can_transform = false;

  // List of callee names (one for each region).
  llvm::SmallVector<StringRef, 2> callee_names;

  // Analyzes the given calls (from regions attached to the same parent op) to