blob: d70e2b82af615d8443bc8556d863ed636a1bf1c3 [file] [log] [blame]
// Copyright 2024 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.packages;
import com.google.auto.value.AutoValue;
import com.google.common.base.Preconditions;
import com.google.devtools.build.lib.cmdline.PackageIdentifier;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.server.FailureDetails.PackageLoading.Code;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import javax.annotation.Nullable;
import net.starlark.java.eval.EvalException;
import net.starlark.java.eval.Mutability;
import net.starlark.java.eval.Starlark;
import net.starlark.java.eval.StarlarkFunction;
import net.starlark.java.eval.StarlarkSemantics;
import net.starlark.java.eval.StarlarkThread;
import net.starlark.java.eval.SymbolGenerator;
/**
* Represents a symbolic macro, defined in a .bzl file, that may be instantiated during Package
* evaluation.
*
* <p>This is analogous to {@link RuleClass}. In essence, a {@code MacroClass} consists of the
* macro's schema and its implementation function.
*/
public final class MacroClass {
private final String name;
private final StarlarkFunction implementation;
public MacroClass(String name, StarlarkFunction implementation) {
this.name = name;
this.implementation = implementation;
}
/** Returns the macro's exported name. */
public String getName() {
return name;
}
public StarlarkFunction getImplementation() {
return implementation;
}
/** Builder for {@link MacroClass}. */
public static final class Builder {
private final StarlarkFunction implementation;
@Nullable private String name = null;
public Builder(StarlarkFunction implementation) {
this.implementation = implementation;
}
@CanIgnoreReturnValue
public Builder setName(String name) {
this.name = name;
return this;
}
public MacroClass build() {
Preconditions.checkNotNull(name);
return new MacroClass(name, implementation);
}
}
/**
* Executes a symbolic macro's implementation function, in a new Starlark thread, mutating the
* given package under construction.
*/
// TODO: #19922 - Take a new type, PackagePiece.Builder, in place of Package.Builder. PackagePiece
// would represent the collection of targets/macros instantiated by expanding a single symbolic
// macro.
public static void executeMacroImplementation(
MacroInstance macro, Package.Builder builder, StarlarkSemantics semantics)
throws InterruptedException {
try (Mutability mu =
Mutability.create("macro", builder.getPackageIdentifier(), macro.getName())) {
StarlarkThread thread =
StarlarkThread.create(
mu,
semantics,
/* contextDescription= */ "",
SymbolGenerator.create(
MacroId.create(builder.getPackageIdentifier(), macro.getName())));
thread.setPrintHandler(Event.makeDebugPrintHandler(builder.getLocalEventHandler()));
// TODO: #19922 - Technically the embedded SymbolGenerator field should use a different key
// than the one in the main BUILD thread, but that'll be fixed when we change the type to
// PackagePiece.Builder.
builder.storeInThread(thread);
// TODO: #19922 - If we want to support creating analysis_test rules inside symbolic macros,
// we'd need to call `thread.setThreadLocal(RuleDefinitionEnvironment.class,
// ruleClassProvider)`. In that case we'll need to consider how to get access to the
// ConfiguredRuleClassProvider. For instance, we could put it in the builder.
try {
Starlark.fastcall(
thread,
macro.getMacroClass().getImplementation(),
/* positional= */ new Object[] {},
/* named= */ new Object[] {"name", macro.getName()});
} catch (EvalException ex) {
builder
.getLocalEventHandler()
.handle(
Package.error(
/* location= */ null, ex.getMessageWithStack(), Code.STARLARK_EVAL_ERROR));
builder.setContainsErrors();
}
}
}
@AutoValue
abstract static class MacroId {
static MacroId create(PackageIdentifier id, String name) {
return new AutoValue_MacroClass_MacroId(id, name);
}
abstract PackageIdentifier packageId();
abstract String name();
}
}