* If a `groovy-all(-indy)` Jar is found on `classpath`, that jar will be added to `groovyClasspath`.
* If a `groovy(-indy)` jar is found on `classpath`, and the project has at least one repository declared, a corresponding `groovy(-indy)` repository dependency will be added to `groovyClasspath`.

    return failure();

  // Reshape recurrent weights to vectors if indy behaviour is enabled.
  // IndyLSTMs are a LSTM variant with diagonal recurrent weight
  // matrices. For optimization purposes these are provided as vectors.
  Value recurrent_to_input_weights =
      indy ? mlir::cast<Value>(
                 CreateFlattenOP(recurrent_weights_array->getResult(0),

                    }
                }
            }
        """

        file("buildSrc/build.gradle") << """
        compileGroovy {
            groovyOptions.optimizationOptions.indy = $enableIndy
        }
        """

        buildScript("""
            apply plugin: SomePlugin
        """)
    }

    abstract TestFile file(Object... path)

    public GroovyRuntime(Project project) {
        this.project = (ProjectInternal) project;
    }

    /**
     * Searches the specified class path for Groovy Jars ({@code groovy(-indy)}, {@code groovy-all(-indy)}) and returns a corresponding class path for executing Groovy tools such as the Groovy

            }
        }
    }

    def "mixing variant aware and artifact selection is forbidden"() {
        buildFile << """
            dependencies {
                conf('org:lib:1.0:indy') {
                    capabilities {
                        requireCapability("org:lib")
                    }
                }
            }
        """

        when:
        fails ':checkDeps'

    static {
        SUPPORTED_BY_JDK = groovyVersionsSupportedByJdk(JavaVersion.current())
        SUPPORTS_GROOVYDOC = VersionCoverage.versionsAtLeast(SUPPORTED_BY_JDK, "1.6.9")
        // Indy compilation doesn't work in 2.2.2 and before
        SUPPORTS_INDY = VersionCoverage.versionsAtLeast(SUPPORTED_BY_JDK, "2.3.0")
        SUPPORTS_TIMESTAMP = VersionCoverage.versionsAtLeast(SUPPORTED_BY_JDK, "2.4.6")

                                    OpBuilder* builder);

LogicalResult ConvertKerasLSTMLayer(mlir::func::FuncOp func_op,
                                    OpBuilder* builder, bool indy);

}  // end namespace TFL
}  // end namespace mlir

        groovyDependency = groovyModuleDependency("groovy", versionNumber)
    }

    def "compileGoodCode"() {
        if (module == "groovy-all") {
            // No groovy-all for indy variant
            Assume.assumeTrue(versionClassifier != "indy")
        }
        groovyDependency = groovyModuleDependency(module, versionNumber)

        expect:
        succeeds("compileGroovy")
        groovyClassFile("Person.class").exists()

     * Only takes effect when compiling against Groovy 1.8 or higher.
     *
     * <p>Known options are:
     *
     * <dl>
     *     <dt>indy
     *     <dd>Use the invokedynamic bytecode instruction. Requires JDK7 or higher and Groovy 2.0 or higher. Disabled by default.
     *     <dt>int

    func.eraseBody();
    func.addEntryBlock();
    OpBuilder builder(func.getBody());
    if (failed(ConvertKerasLSTMLayer(func, &builder)))
      return signalPassFailure();
  }

  // LSTM `func::FuncOps` with indy behavior always have the `tf.api_implements`
  // function attribute prefixed with `"indy_lstm_"`.
  // IndyLSTMs have diagonal recurrent weight matrices and can benefit from