/**
* Returns the xcode version number corresponding to the {@code --xcode_version} flag, if there is
* an available {@code xcode_version} target which recognizes the flag value as either an official
* version or an alias. Returns null if no such target is found.
*/
@Nullable
private DottedVersion resolveExplicitlyDefinedVersion(RuleContext ruleContext) {
AppleConfiguration configuration = ruleContext.getFragment(AppleConfiguration.class);
Optional<DottedVersion> versionOverrideFlag = configuration.getXcodeVersionOverrideFlag();
if (versionOverrideFlag.isPresent()) {
// The version override flag is not necessarily an actual version - it may be a version
// alias.
DottedVersion explicitVerison =
aliasesToVersionMap(ruleContext).get(versionOverrideFlag.get().toString());
if (explicitVerison != null) {
return explicitVerison;
}
} else { // No override specified. Use default.
XcodeVersionProvider defaultProvider =
ruleContext.getPrerequisite(
XcodeConfigRule.DEFAULT_ATTR_NAME, Mode.TARGET, XcodeVersionProvider.class);
if (defaultProvider != null) {
return defaultProvider.getVersion();
}
}
boolean requireDefinedVersions =
ruleContext.attributes().get(XcodeConfigRule.REQUIRE_DEFINED_VERSIONS_ATTR_NAME, BOOLEAN);
if (requireDefinedVersions) {
ruleContext.ruleError(
"xcode version config required an explicitly defined version, but none was available");
}
return null;
}
private TransitiveLipoInfoProvider collectTransitiveLipoInfo(CcCompilationOutputs outputs) {
if (CppHelper.getFdoSupport(ruleContext).getFdoRoot() == null) {
return TransitiveLipoInfoProvider.EMPTY;
}
NestedSetBuilder<IncludeScannable> scannableBuilder = NestedSetBuilder.stableOrder();
// TODO(bazel-team): Only fetch the STL prerequisite in one place.
TransitiveInfoCollection stl = ruleContext.getPrerequisite(":stl", Mode.TARGET);
if (stl != null) {
TransitiveLipoInfoProvider provider = stl.getProvider(TransitiveLipoInfoProvider.class);
if (provider != null) {
scannableBuilder.addTransitive(provider.getTransitiveIncludeScannables());
}
}
for (TransitiveLipoInfoProvider dep :
AnalysisUtils.getProviders(deps, TransitiveLipoInfoProvider.class)) {
scannableBuilder.addTransitive(dep.getTransitiveIncludeScannables());
}
for (IncludeScannable scannable : outputs.getLipoScannables()) {
Preconditions.checkState(scannable.getIncludeScannerSources().size() == 1);
scannableBuilder.add(scannable);
}
return new TransitiveLipoInfoProvider(scannableBuilder.build());
}
/**
* Returns the Android SDK associated with the rule being analyzed or null if the Android SDK is
* not specified.
*/
public static AndroidSdkProvider fromRuleContext(RuleContext ruleContext) {
TransitiveInfoCollection androidSdkDep =
ruleContext.getPrerequisite(":android_sdk", Mode.TARGET);
AndroidSdkProvider androidSdk =
androidSdkDep == null ? null : androidSdkDep.getProvider(AndroidSdkProvider.class);
return androidSdk;
}
private NestedSet<Artifact> getFiles(RuleContext context, String attribute) {
TransitiveInfoCollection dep = context.getPrerequisite(attribute, Mode.HOST);
MiddlemanProvider middlemanProvider = dep.getProvider(MiddlemanProvider.class);
// We use the middleman if we can (if the dep is a filegroup), otherwise, just the regular
// filesToBuild (e.g. if it is a simple input file)
return middlemanProvider != null
? middlemanProvider.getMiddlemanArtifact()
: dep.getProvider(FileProvider.class).getFilesToBuild();
}
private CppModuleMap createCrosstoolModuleMap(RuleContext ruleContext) {
if (ruleContext.getPrerequisite("module_map", Mode.HOST) == null) {
return null;
}
Artifact moduleMapArtifact = ruleContext.getPrerequisiteArtifact("module_map", Mode.HOST);
if (moduleMapArtifact == null) {
return null;
}
return new CppModuleMap(moduleMapArtifact, "crosstool");
}
private static ImmutableMap<Artifact, IncludeScannable> getLipoScannableMap(
RuleContext ruleContext) {
if (!ruleContext.getFragment(CppConfiguration.class).isLipoOptimization()) {
return null;
}
LipoContextProvider provider =
ruleContext.getPrerequisite(
":lipo_context_collector", Mode.DONT_CHECK, LipoContextProvider.class);
return provider.getIncludeScannables();
}
public static AndroidResourcesProvider getAndroidResources(RuleContext ruleContext) {
if (!ruleContext.attributes().has("resources", BuildType.LABEL)) {
return null;
}
TransitiveInfoCollection prerequisite = ruleContext.getPrerequisite("resources", Mode.TARGET);
if (prerequisite == null) {
return null;
}
return prerequisite.getProvider(AndroidResourcesProvider.class);
}
private Optional<Artifact> xctestIpa() {
FileProvider fileProvider =
ruleContext.getPrerequisite("xctest_app", Mode.TARGET, FileProvider.class);
if (fileProvider == null) {
return Optional.absent();
}
List<Artifact> files =
Artifact.filterFiles(fileProvider.getFilesToBuild(), FileType.of(".ipa"));
if (files.size() == 0) {
return Optional.absent();
} else if (files.size() == 1) {
return Optional.of(Iterables.getOnlyElement(files));
} else {
throw new IllegalStateException("Expected 0 or 1 files in xctest_app, got: " + files);
}
}
private Iterable<CppModuleMap> collectModuleMaps() {
// Cpp module maps may be null for some rules. We filter the nulls out at the end.
List<CppModuleMap> result = new ArrayList<>();
Iterables.addAll(result, Iterables.transform(deps, CPP_DEPS_TO_MODULES));
if (ruleContext.getRule().getAttributeDefinition(":stl") != null) {
CppCompilationContext stl =
ruleContext.getPrerequisite(":stl", Mode.TARGET, CppCompilationContext.class);
if (stl != null) {
result.add(stl.getCppModuleMap());
}
}
CcToolchainProvider toolchain = CppHelper.getToolchain(ruleContext);
if (toolchain != null) {
result.add(toolchain.getCppCompilationContext().getCppModuleMap());
}
return Iterables.filter(result, Predicates.<CppModuleMap>notNull());
}
private String getOverridePackage(RuleContext ruleContext) {
// It seems that we sometimes rename the app for God-knows-what reason. If that is the case,
// pass this information to the stubifier script.
if (ruleContext.attributes().isAttributeValueExplicitlySpecified("application_id")) {
return ruleContext.attributes().get("application_id", Type.STRING);
}
TransitiveInfoCollection resourcesPrerequisite =
ruleContext.getPrerequisite("resources", Mode.TARGET);
if (resourcesPrerequisite != null) {
ResourceContainer resourceContainer =
Iterables.getOnlyElement(
resourcesPrerequisite
.getProvider(AndroidResourcesProvider.class)
.getTransitiveAndroidResources());
return resourceContainer.getRenameManifestPackage();
} else {
return null;
}
}
@Override
public ConfiguredTarget create(RuleContext ruleContext)
throws RuleErrorException, InterruptedException {
TransitiveInfoCollection lipoContextCollector =
ruleContext.getPrerequisite(":lipo_context_collector", Mode.DONT_CHECK);
if (lipoContextCollector != null
&& lipoContextCollector.getProvider(LipoContextProvider.class) == null) {
ruleContext.ruleError("--lipo_context must point to a cc_binary or a cc_test rule");
return null;
}
CppConfiguration cppConfiguration =
Preconditions.checkNotNull(ruleContext.getFragment(CppConfiguration.class));
Path fdoZip =
ruleContext.getConfiguration().getCompilationMode() == CompilationMode.OPT
? cppConfiguration.getFdoZip()
: null;
SkyKey fdoKey =
FdoSupportValue.key(
cppConfiguration.getLipoMode(), fdoZip, cppConfiguration.getFdoInstrument());
SkyFunction.Environment skyframeEnv = ruleContext.getAnalysisEnvironment().getSkyframeEnv();
FdoSupportValue fdoSupport;
try {
fdoSupport =
(FdoSupportValue)
skyframeEnv.getValueOrThrow(fdoKey, FdoException.class, IOException.class);
} catch (FdoException | IOException e) {
ruleContext.ruleError("cannot initialize FDO: " + e.getMessage());
return null;
}
if (skyframeEnv.valuesMissing()) {
return null;
}
final Label label = ruleContext.getLabel();
final NestedSet<Artifact> crosstool =
ruleContext
.getPrerequisite("all_files", Mode.HOST)
.getProvider(FileProvider.class)
.getFilesToBuild();
final NestedSet<Artifact> crosstoolMiddleman = getFiles(ruleContext, "all_files");
final NestedSet<Artifact> compile = getFiles(ruleContext, "compiler_files");
final NestedSet<Artifact> strip = getFiles(ruleContext, "strip_files");
final NestedSet<Artifact> objcopy = getFiles(ruleContext, "objcopy_files");
final NestedSet<Artifact> link = getFiles(ruleContext, "linker_files");
final NestedSet<Artifact> dwp = getFiles(ruleContext, "dwp_files");
final NestedSet<Artifact> libcLink = inputsForLibc(ruleContext);
String purposePrefix = Actions.escapeLabel(label) + "_";
String runtimeSolibDirBase = "_solib_" + "_" + Actions.escapeLabel(label);
final PathFragment runtimeSolibDir =
ruleContext.getConfiguration().getBinFragment().getRelative(runtimeSolibDirBase);
// Static runtime inputs.
TransitiveInfoCollection staticRuntimeLibDep =
selectDep(ruleContext, "static_runtime_libs", cppConfiguration.getStaticRuntimeLibsLabel());
final NestedSet<Artifact> staticRuntimeLinkInputs;
final Artifact staticRuntimeLinkMiddleman;
if (cppConfiguration.supportsEmbeddedRuntimes()) {
staticRuntimeLinkInputs =
staticRuntimeLibDep.getProvider(FileProvider.class).getFilesToBuild();
} else {
staticRuntimeLinkInputs = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
if (!staticRuntimeLinkInputs.isEmpty()) {
NestedSet<Artifact> staticRuntimeLinkMiddlemanSet =
CompilationHelper.getAggregatingMiddleman(
ruleContext, purposePrefix + "static_runtime_link", staticRuntimeLibDep);
staticRuntimeLinkMiddleman =
staticRuntimeLinkMiddlemanSet.isEmpty()
? null
: Iterables.getOnlyElement(staticRuntimeLinkMiddlemanSet);
} else {
staticRuntimeLinkMiddleman = null;
}
Preconditions.checkState(
(staticRuntimeLinkMiddleman == null) == staticRuntimeLinkInputs.isEmpty());
// Dynamic runtime inputs.
TransitiveInfoCollection dynamicRuntimeLibDep =
selectDep(
ruleContext, "dynamic_runtime_libs", cppConfiguration.getDynamicRuntimeLibsLabel());
final NestedSet<Artifact> dynamicRuntimeLinkInputs;
final Artifact dynamicRuntimeLinkMiddleman;
if (cppConfiguration.supportsEmbeddedRuntimes()) {
NestedSetBuilder<Artifact> dynamicRuntimeLinkInputsBuilder = NestedSetBuilder.stableOrder();
for (Artifact artifact :
dynamicRuntimeLibDep.getProvider(FileProvider.class).getFilesToBuild()) {
if (CppHelper.SHARED_LIBRARY_FILETYPES.matches(artifact.getFilename())) {
dynamicRuntimeLinkInputsBuilder.add(
SolibSymlinkAction.getCppRuntimeSymlink(
ruleContext, artifact, runtimeSolibDirBase, ruleContext.getConfiguration()));
} else {
dynamicRuntimeLinkInputsBuilder.add(artifact);
}
}
dynamicRuntimeLinkInputs = dynamicRuntimeLinkInputsBuilder.build();
} else {
dynamicRuntimeLinkInputs = NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
if (!dynamicRuntimeLinkInputs.isEmpty()) {
List<Artifact> dynamicRuntimeLinkMiddlemanSet =
CppHelper.getAggregatingMiddlemanForCppRuntimes(
ruleContext,
purposePrefix + "dynamic_runtime_link",
dynamicRuntimeLibDep,
runtimeSolibDirBase,
ruleContext.getConfiguration());
dynamicRuntimeLinkMiddleman =
dynamicRuntimeLinkMiddlemanSet.isEmpty()
? null
: Iterables.getOnlyElement(dynamicRuntimeLinkMiddlemanSet);
} else {
dynamicRuntimeLinkMiddleman = null;
}
Preconditions.checkState(
(dynamicRuntimeLinkMiddleman == null) == dynamicRuntimeLinkInputs.isEmpty());
CppCompilationContext.Builder contextBuilder = new CppCompilationContext.Builder(ruleContext);
CppModuleMap moduleMap = createCrosstoolModuleMap(ruleContext);
if (moduleMap != null) {
contextBuilder.setCppModuleMap(moduleMap);
}
final CppCompilationContext context = contextBuilder.build();
boolean supportsParamFiles = ruleContext.attributes().get("supports_param_files", BOOLEAN);
boolean supportsHeaderParsing =
ruleContext.attributes().get("supports_header_parsing", BOOLEAN);
NestedSetBuilder<Pair<String, String>> coverageEnvironment = NestedSetBuilder.compileOrder();
coverageEnvironment.add(
Pair.of("COVERAGE_GCOV_PATH", cppConfiguration.getGcovExecutable().getPathString()));
if (cppConfiguration.getFdoInstrument() != null) {
coverageEnvironment.add(
Pair.of("FDO_DIR", cppConfiguration.getFdoInstrument().getPathString()));
}
CcToolchainProvider provider =
new CcToolchainProvider(
cppConfiguration,
crosstool,
fullInputsForCrosstool(ruleContext, crosstoolMiddleman),
compile,
strip,
objcopy,
fullInputsForLink(ruleContext, link),
dwp,
libcLink,
staticRuntimeLinkInputs,
staticRuntimeLinkMiddleman,
dynamicRuntimeLinkInputs,
dynamicRuntimeLinkMiddleman,
runtimeSolibDir,
context,
supportsParamFiles,
supportsHeaderParsing,
getBuildVariables(ruleContext),
getBuiltinIncludes(ruleContext),
coverageEnvironment.build());
RuleConfiguredTargetBuilder builder =
new RuleConfiguredTargetBuilder(ruleContext)
.add(CcToolchainProvider.class, provider)
.add(FdoSupportProvider.class, new FdoSupportProvider(fdoSupport.getFdoSupport()))
.setFilesToBuild(new NestedSetBuilder<Artifact>(Order.STABLE_ORDER).build())
.add(RunfilesProvider.class, RunfilesProvider.simple(Runfiles.EMPTY));
// If output_license is specified on the cc_toolchain rule, override the transitive licenses
// with that one. This is necessary because cc_toolchain is used in the target configuration,
// but it is sort-of-kind-of a tool, but various parts of it are linked into the output...
// ...so we trust the judgment of the author of the cc_toolchain rule to figure out what
// licenses should be propagated to C++ targets.
License outputLicense = ruleContext.getRule().getToolOutputLicense(ruleContext.attributes());
if (outputLicense != null && outputLicense != License.NO_LICENSE) {
final NestedSet<TargetLicense> license =
NestedSetBuilder.create(
Order.STABLE_ORDER, new TargetLicense(ruleContext.getLabel(), outputLicense));
LicensesProvider licensesProvider =
new LicensesProvider() {
@Override
public NestedSet<TargetLicense> getTransitiveLicenses() {
return license;
}
};
builder.add(LicensesProvider.class, licensesProvider);
}
return builder.build();
}
private DependenciesResult processDependencies(
ConfiguredTarget base,
RuleContext ruleContext,
AndroidStudioInfoFilesProvider.Builder providerBuilder) {
// Calculate direct dependencies
ImmutableList.Builder<TransitiveInfoCollection> directDepsBuilder = ImmutableList.builder();
for (PrerequisiteAttr prerequisiteAttr : PREREQUISITE_ATTRS) {
if (ruleContext.attributes().has(prerequisiteAttr.name, prerequisiteAttr.type)) {
directDepsBuilder.addAll(ruleContext.getPrerequisites(prerequisiteAttr.name, Mode.TARGET));
}
}
List<TransitiveInfoCollection> directDeps = directDepsBuilder.build();
// Add exports from direct dependencies
NestedSetBuilder<Label> dependenciesBuilder = NestedSetBuilder.stableOrder();
for (AndroidStudioInfoFilesProvider depProvider :
AnalysisUtils.getProviders(directDeps, AndroidStudioInfoFilesProvider.class)) {
dependenciesBuilder.addTransitive(depProvider.getExportedDeps());
}
for (TransitiveInfoCollection dep : directDeps) {
dependenciesBuilder.add(dep.getLabel());
}
NestedSet<Label> dependencies = dependenciesBuilder.build();
// Propagate my own exports
JavaExportsProvider javaExportsProvider = base.getProvider(JavaExportsProvider.class);
if (javaExportsProvider != null) {
providerBuilder
.exportedDepsBuilder()
.addTransitive(javaExportsProvider.getTransitiveExports());
}
// android_library without sources exports all its deps
if (ruleContext.getRule().getRuleClass().equals("android_library")) {
JavaSourceInfoProvider sourceInfoProvider = base.getProvider(JavaSourceInfoProvider.class);
boolean hasSources =
sourceInfoProvider != null && !sourceInfoProvider.getSourceFiles().isEmpty();
if (!hasSources) {
for (TransitiveInfoCollection dep : directDeps) {
providerBuilder.exportedDepsBuilder().add(dep.getLabel());
}
}
}
// runtime_deps
List<? extends TransitiveInfoCollection> runtimeDeps = ImmutableList.of();
NestedSetBuilder<Label> runtimeDepsBuilder = NestedSetBuilder.stableOrder();
if (ruleContext.attributes().has("runtime_deps", BuildType.LABEL_LIST)) {
runtimeDeps = ruleContext.getPrerequisites("runtime_deps", Mode.TARGET);
for (TransitiveInfoCollection dep : runtimeDeps) {
runtimeDepsBuilder.add(dep.getLabel());
}
}
// resources
@Nullable
TransitiveInfoCollection resources =
ruleContext.attributes().has("resources", BuildType.LABEL)
? ruleContext.getPrerequisite("resources", Mode.TARGET)
: null;
// Propagate providers from all prerequisites (deps + runtime_deps)
ImmutableList.Builder<TransitiveInfoCollection> prerequisitesBuilder = ImmutableList.builder();
prerequisitesBuilder.addAll(directDeps);
prerequisitesBuilder.addAll(runtimeDeps);
if (resources != null) {
prerequisitesBuilder.add(resources);
}
List<TransitiveInfoCollection> prerequisites = prerequisitesBuilder.build();
for (AndroidStudioInfoFilesProvider depProvider :
AnalysisUtils.getProviders(prerequisites, AndroidStudioInfoFilesProvider.class)) {
providerBuilder.ideInfoFilesBuilder().addTransitive(depProvider.getIdeInfoFiles());
providerBuilder.ideInfoTextFilesBuilder().addTransitive(depProvider.getIdeInfoTextFiles());
providerBuilder.ideResolveFilesBuilder().addTransitive(depProvider.getIdeResolveFiles());
}
return new DependenciesResult(
dependencies, runtimeDepsBuilder.build(), resources != null ? resources.getLabel() : null);
}
/**
* Packages up the manifest with resources, and generates the R.java.
*
* @deprecated in favor of {@link ApplicationManifest#packWithDataAndResources}.
*/
@Deprecated
public ResourceApk packWithResources(
Artifact resourceApk,
RuleContext ruleContext,
NestedSet<ResourceContainer> resourceContainers,
boolean createSource,
Artifact proguardCfg) {
TransitiveInfoCollection resourcesPrerequisite =
ruleContext.getPrerequisite("resources", Mode.TARGET);
ResourceContainer resourceContainer =
Iterables.getOnlyElement(
resourcesPrerequisite
.getProvider(AndroidResourcesProvider.class)
.getTransitiveAndroidResources());
// Dealing with Android library projects
if (Iterables.size(resourceContainers) > 1) {
if (resourceContainer.getConstantsInlined()
&& !resourceContainer.getArtifacts(ResourceType.RESOURCES).isEmpty()) {
ruleContext.ruleError(
"This android_binary depends on an android_library, so the"
+ " resources '"
+ AndroidCommon.getAndroidResources(ruleContext).getLabel()
+ "' should have the attribute inline_constants set to 0");
throw new RuleConfigurationException();
}
}
// This binary depends on a library project, so we need to regenerate the
// resources. The resulting sources and apk will combine all the resources
// contained in the transitive closure of the binary.
AndroidAaptActionHelper aaptActionHelper =
new AndroidAaptActionHelper(
ruleContext, getManifest(), Lists.newArrayList(resourceContainers));
List<String> resourceConfigurationFilters =
ruleContext.getTokenizedStringListAttr("resource_configuration_filters");
List<String> uncompressedExtensions =
ruleContext.getTokenizedStringListAttr("nocompress_extensions");
ImmutableList.Builder<String> additionalAaptOpts = ImmutableList.<String>builder();
for (String extension : uncompressedExtensions) {
additionalAaptOpts.add("-0").add(extension);
}
if (!resourceConfigurationFilters.isEmpty()) {
additionalAaptOpts.add("-c").add(Joiner.on(",").join(resourceConfigurationFilters));
}
Artifact javaSourcesJar = null;
if (createSource) {
javaSourcesJar =
ruleContext.getImplicitOutputArtifact(AndroidRuleClasses.ANDROID_JAVA_SOURCE_JAR);
aaptActionHelper.createGenerateResourceSymbolsAction(
javaSourcesJar, null, resourceContainer.getJavaPackage(), true);
}
List<String> densities = ruleContext.getTokenizedStringListAttr("densities");
aaptActionHelper.createGenerateApkAction(
resourceApk,
resourceContainer.getRenameManifestPackage(),
additionalAaptOpts.build(),
densities);
ResourceContainer updatedResources =
new ResourceContainer(
ruleContext.getLabel(),
resourceContainer.getJavaPackage(),
resourceContainer.getRenameManifestPackage(),
resourceContainer.getConstantsInlined(),
resourceApk,
getManifest(),
javaSourcesJar,
resourceContainer.getArtifacts(ResourceType.ASSETS),
resourceContainer.getArtifacts(ResourceType.RESOURCES),
resourceContainer.getRoots(ResourceType.ASSETS),
resourceContainer.getRoots(ResourceType.RESOURCES),
resourceContainer.isManifestExported(),
resourceContainer.getRTxt(),
null);
aaptActionHelper.createGenerateProguardAction(proguardCfg);
return new ResourceApk(
resourceApk,
updatedResources.getJavaSourceJar(),
resourceContainers,
updatedResources,
manifest,
proguardCfg,
true);
}
private NestedSet<Artifact> inputsForLibc(RuleContext ruleContext) {
TransitiveInfoCollection libc = ruleContext.getPrerequisite(":libc_top", Mode.HOST);
return libc != null
? libc.getProvider(FileProvider.class).getFilesToBuild()
: NestedSetBuilder.<Artifact>emptySet(Order.STABLE_ORDER);
}
/** Runfiles required in order to use the specified target device. */
private NestedSet<Artifact> labDeviceRunfiles() {
return ruleContext
.getPrerequisite("ios_test_target_device", Mode.TARGET, RunfilesProvider.class)
.getDefaultRunfiles()
.getAllArtifacts();
}
@Nullable
private IosTestSubstitutionProvider iosLabDeviceSubstitutions() {
return ruleContext.getPrerequisite(
"ios_test_target_device", Mode.TARGET, IosTestSubstitutionProvider.class);
}
/** Gets the test template for lab devices. */
private Artifact testTemplateForLabDevice() {
return ruleContext
.getPrerequisite("ios_test_target_device", Mode.TARGET, LabDeviceTemplateProvider.class)
.getLabDeviceTemplate();
}
private IosTestSubstitutionProvider deviceSubstitutions() {
return ruleContext.getPrerequisite(
"target_device", Mode.TARGET, IosTestSubstitutionProvider.class);
}
private static Artifact getRunUnderExecutable(RuleContext ruleContext) {
TransitiveInfoCollection runUnderTarget = ruleContext.getPrerequisite(":run_under", Mode.DATA);
return runUnderTarget == null
? null
: runUnderTarget.getProvider(FilesToRunProvider.class).getExecutable();
}
/**
* {@inheritDoc}
*
* <p>Creates a target, including registering actions, just as {@link #create(RuleContext)} does.
* The difference between {@link #create(RuleContext)} and this method is that this method does
* only what is needed to support tests on the environment besides generate the Xcodeproj file and
* build the app and test {@code .ipa}s. The {@link #create(RuleContext)} method delegates to this
* method.
*/
@Override
public final ConfiguredTarget create(RuleContext ruleContext)
throws InterruptedException, RuleErrorException {
ProtobufSupport protoSupport =
new ProtobufSupport(ruleContext).registerGenerationActions().registerCompilationActions();
Optional<ObjcProvider> protosObjcProvider = protoSupport.getObjcProvider();
Optional<XcodeProvider> protosXcodeProvider = protoSupport.getXcodeProvider();
ObjcCommon common = common(ruleContext, protosObjcProvider);
if (!common.getCompilationArtifacts().get().getArchive().isPresent()) {
ruleContext.ruleError(REQUIRES_SOURCE_ERROR);
}
if (!ruleContext.getFragment(AppleConfiguration.class).getIosMultiCpus().isEmpty()) {
ruleContext.ruleError(NO_MULTI_CPUS_ERROR);
}
XcodeProvider.Builder xcodeProviderBuilder =
new XcodeProvider.Builder().addPropagatedDependencies(protosXcodeProvider.asSet());
NestedSetBuilder<Artifact> filesToBuild = NestedSetBuilder.stableOrder();
addResourceFilesToBuild(ruleContext, common.getObjcProvider(), filesToBuild);
XcodeProductType productType = getProductType(ruleContext);
ExtraLinkArgs extraLinkArgs;
Iterable<Artifact> extraLinkInputs;
String bundleFormat;
if (!isXcTest(ruleContext)) {
extraLinkArgs = new ExtraLinkArgs();
extraLinkInputs = ImmutableList.of();
bundleFormat = ReleaseBundlingSupport.APP_BUNDLE_DIR_FORMAT;
} else {
XcodeProvider appIpaXcodeProvider =
ruleContext.getPrerequisite(XCTEST_APP_ATTR, Mode.TARGET, XcodeProvider.class);
xcodeProviderBuilder.setTestHost(appIpaXcodeProvider).setProductType(productType);
XcTestAppProvider testApp = xcTestAppProvider(ruleContext);
Artifact bundleLoader = testApp.getBundleLoader();
// -bundle causes this binary to be linked as a bundle and not require an entry point
// (i.e. main())
// -bundle_loader causes the code in this test to have access to the symbols in the test rig,
// or more specifically, the flag causes ld to consider the given binary when checking for
// missing symbols.
// -rpath @loader_path/Frameworks allows test bundles to load dylibs from the app's
// Frameworks directory.
extraLinkArgs =
new ExtraLinkArgs(
"-bundle",
"-bundle_loader",
bundleLoader.getExecPathString(),
"-Xlinker",
"-rpath",
"-Xlinker",
"@loader_path/Frameworks");
extraLinkInputs = ImmutableList.of(bundleLoader);
bundleFormat = ReleaseBundlingSupport.XCTEST_BUNDLE_DIR_FORMAT;
filesToBuild.add(testApp.getIpa());
}
J2ObjcMappingFileProvider j2ObjcMappingFileProvider =
J2ObjcMappingFileProvider.union(
ruleContext.getPrerequisites("deps", Mode.TARGET, J2ObjcMappingFileProvider.class));
J2ObjcEntryClassProvider j2ObjcEntryClassProvider =
new J2ObjcEntryClassProvider.Builder()
.addTransitive(
ruleContext.getPrerequisites("deps", Mode.TARGET, J2ObjcEntryClassProvider.class))
.build();
new CompilationSupport(ruleContext)
.registerLinkActions(
common.getObjcProvider(),
j2ObjcMappingFileProvider,
j2ObjcEntryClassProvider,
extraLinkArgs,
extraLinkInputs,
DsymOutputType.TEST)
.registerCompileAndArchiveActions(common)
.registerFullyLinkAction(
common.getObjcProvider(),
ruleContext.getImplicitOutputArtifact(CompilationSupport.FULLY_LINKED_LIB))
.addXcodeSettings(xcodeProviderBuilder, common)
.validateAttributes();
AppleConfiguration appleConfiguration = ruleContext.getFragment(AppleConfiguration.class);
new ReleaseBundlingSupport(
ruleContext,
common.getObjcProvider(),
LinkedBinary.LOCAL_AND_DEPENDENCIES,
bundleFormat,
appleConfiguration.getMinimumOsForPlatformType(PlatformType.IOS),
appleConfiguration.getMultiArchPlatform(PlatformType.IOS))
.registerActions(DsymOutputType.TEST)
.addXcodeSettings(xcodeProviderBuilder)
.addFilesToBuild(filesToBuild, Optional.of(DsymOutputType.TEST))
.validateResources()
.validateAttributes();
new ResourceSupport(ruleContext).validateAttributes().addXcodeSettings(xcodeProviderBuilder);
new XcodeSupport(ruleContext)
.addXcodeSettings(xcodeProviderBuilder, common.getObjcProvider(), productType)
.addDependencies(xcodeProviderBuilder, new Attribute("bundles", Mode.TARGET))
.addDependencies(xcodeProviderBuilder, new Attribute("deps", Mode.TARGET))
.addNonPropagatedDependencies(
xcodeProviderBuilder, new Attribute("non_propagated_deps", Mode.TARGET))
.addFilesToBuild(filesToBuild)
.registerActions(xcodeProviderBuilder.build());
XcodeProvider xcodeProvider = xcodeProviderBuilder.build();
NestedSet<Artifact> filesToBuildSet = filesToBuild.build();
Runfiles.Builder runfilesBuilder =
new Runfiles.Builder(
ruleContext.getWorkspaceName(),
ruleContext.getConfiguration().legacyExternalRunfiles())
.addRunfiles(ruleContext, RunfilesProvider.DEFAULT_RUNFILES);
NestedSetBuilder<Artifact> filesToBuildBuilder =
NestedSetBuilder.<Artifact>stableOrder().addTransitive(filesToBuildSet);
InstrumentedFilesProvider instrumentedFilesProvider =
new CompilationSupport(ruleContext).getInstrumentedFilesProvider(common);
TestSupport testSupport =
new TestSupport(ruleContext)
.registerTestRunnerActions()
.addRunfiles(runfilesBuilder, instrumentedFilesProvider)
.addFilesToBuild(filesToBuildBuilder);
Artifact executable = testSupport.generatedTestScript();
Runfiles runfiles = runfilesBuilder.build();
RunfilesSupport runfilesSupport =
RunfilesSupport.withExecutable(ruleContext, runfiles, executable);
ImmutableMap.Builder<String, String> execInfoMapBuilder = new ImmutableMap.Builder<>();
execInfoMapBuilder.put(ExecutionRequirements.REQUIRES_DARWIN, "");
if (ruleContext.getFragment(ObjcConfiguration.class).runMemleaks()) {
execInfoMapBuilder.put("nosandbox", "");
}
return new RuleConfiguredTargetBuilder(ruleContext)
.setFilesToBuild(filesToBuildBuilder.build())
.addProvider(xcodeProvider)
.addProvider(RunfilesProvider.simple(runfiles))
.addProvider(new ExecutionInfoProvider(execInfoMapBuilder.build()))
.addProvider(InstrumentedFilesProvider.class, instrumentedFilesProvider)
.addProviders(testSupport.getExtraProviders())
.setRunfilesSupport(runfilesSupport, executable)
.build();
}
/** Returns the {@link XcTestAppProvider} of the {@code xctest_app} attribute. */
protected static XcTestAppProvider xcTestAppProvider(RuleContext ruleContext) {
return ruleContext.getPrerequisite(XCTEST_APP_ATTR, Mode.TARGET, XcTestAppProvider.class);
}