/** * 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); }