/**
     * Get the consumable configuration which produces the {@code apiElements} variant of this feature.
     * This configuration includes all API compilation dependencies as well as the feature's
     * compilation outputs, but does not include {@code implementation}, {@code compileOnly},
     * or {@code runtimeOnly} dependencies.
     *
     * @return The {@code apiElements} configuration.
     */

					Expression: "user.username == 'foo'",
				},
			},
			wantErr: `compilation failed: ERROR: <input>:1:1: undeclared reference to 'user' (in container '')`,
		},
		{
			name: "invalid ClaimMappingCondition",
			expressionAccessors: []ExpressionAccessor{
				&ClaimMappingExpression{
					Expression: "claims + 1",
				},
			},

                """#if swift(>=5.0)
                        XCTFail("Compilation unit compiled with Swift 5+ instead of Swift 4.x");
                    #elseif swift(>=4.0)
                        // Do nothing
                    #else
                        XCTFail("Compilation unit compiled with Swift 3- instead of Swift 4.x");
                    #endif
                """)
        ]
    }

            return delegate.execute(spec);
        } catch (RuntimeException e) {
            // in-process Groovy compilation throws a CompilationFailedException from another classloader, hence testing class name equality
            // TODO:pm Prefer class over class name for equality check once using WorkerExecutor for in-process groovy compilation
            if ((spec.getCompileOptions().isFailOnError() && spec.getGroovyCompileOptions().isFailOnError())

// Whether soft placement is allowed. If true, the marked node is eligible for
// outside compilation.
inline constexpr llvm::StringRef kAllowSoftPlacementAttr =
    "allow_soft_placement";

// Marks a node for XLA compilation. The attribute value indicates the
// compilation device type.
inline constexpr llvm::StringRef kCompileDeviceTypeAttr =
    "_xla_compile_device_type";

}

dependencies {
    implementation localGroovy()
}

// tag::groovy-compilation-avoidance[]
configurations { astTransformation }
dependencies {
    astTransformation(project(":ast-transformation"))
}
tasks.withType(GroovyCompile).configureEach {
    astTransformationClasspath.from(configurations.astTransformation)
}

import org.gradle.api.tasks.scala.ScalaForkOptions;

import javax.annotation.Nullable;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;

/**
 * Options for Scala platform compilation.
 */
public abstract class BaseScalaCompileOptions extends AbstractOptions {

    private static final long serialVersionUID = 0;

    private boolean failOnError = true;

    private boolean deprecation = true;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.instrumentation

import com.google.testing.compile.Compilation
import com.google.testing.compile.JavaFileObjects
import org.gradle.api.JavaVersion
import org.gradle.internal.instrumentation.processor.ConfigurationCacheInstrumentationProcessor
import org.gradle.internal.jvm.Jvm

            Rel(providerExecution, providerClasspath, "Uses", "for compilation")
            Rel_Neighbor(providerClasspath, providerAccessors, "Uses", "for compilation")
            Rel(providerExecution, gradleKotlinDslApi, "Uses", "for compilation")
            Rel(providerExecution, providerImports, "Queries", "for compilation")
        }

/**
 * Debug options for Java compilation. Only take effect if {@link CompileOptions#debug}
 * is set to {@code true}.
 */
public class DebugOptions extends AbstractOptions {
    private static final long serialVersionUID = 0;

    private String debugLevel;

    /**
     * Get a comma-separated list of debug information to be generated during compilation.