| // Copyright 2016 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.rules.objc; |
| |
| import static com.google.devtools.build.lib.rules.objc.ObjcProvider.TOP_LEVEL_MODULE_MAP; |
| |
| import com.google.common.base.Optional; |
| import com.google.common.base.Preconditions; |
| import com.google.common.base.Predicates; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.Iterables; |
| import com.google.devtools.build.lib.actions.Artifact; |
| import com.google.devtools.build.lib.analysis.PrerequisiteArtifacts; |
| import com.google.devtools.build.lib.analysis.RuleConfiguredTarget.Mode; |
| import com.google.devtools.build.lib.analysis.RuleContext; |
| import com.google.devtools.build.lib.cmdline.Label; |
| import com.google.devtools.build.lib.collect.nestedset.NestedSet; |
| import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder; |
| import com.google.devtools.build.lib.packages.BuildType; |
| import com.google.devtools.build.lib.rules.cpp.CcCommon; |
| import com.google.devtools.build.lib.rules.cpp.CppModuleMap; |
| import com.google.devtools.build.lib.syntax.Type; |
| import com.google.devtools.build.lib.util.Pair; |
| import com.google.devtools.build.lib.vfs.PathFragment; |
| import java.util.List; |
| |
| /** |
| * Provides a way to access attributes that are common to all compilation rules. |
| */ |
| // TODO(bazel-team): Delete and move into support-specific attributes classes once ObjcCommon is |
| // gone. |
| final class CompilationAttributes { |
| static class Builder { |
| private final NestedSetBuilder<Artifact> hdrs = NestedSetBuilder.stableOrder(); |
| private final NestedSetBuilder<Artifact> textualHdrs = NestedSetBuilder.stableOrder(); |
| private final NestedSetBuilder<PathFragment> includes = NestedSetBuilder.stableOrder(); |
| private final NestedSetBuilder<PathFragment> sdkIncludes = NestedSetBuilder.stableOrder(); |
| private final ImmutableList.Builder<String> copts = ImmutableList.builder(); |
| private final ImmutableList.Builder<String> linkopts = ImmutableList.builder(); |
| private final NestedSetBuilder<CppModuleMap> moduleMapsForDirectDeps = |
| NestedSetBuilder.stableOrder(); |
| private final NestedSetBuilder<SdkFramework> sdkFrameworks = NestedSetBuilder.stableOrder(); |
| private final NestedSetBuilder<SdkFramework> weakSdkFrameworks = NestedSetBuilder.stableOrder(); |
| private final NestedSetBuilder<String> sdkDylibs = NestedSetBuilder.stableOrder(); |
| private Optional<PathFragment> packageFragment = Optional.absent(); |
| private boolean enableModules; |
| |
| /** |
| * Adds the default values available through the rule's context. |
| */ |
| static Builder fromRuleContext(RuleContext ruleContext) { |
| Builder builder = new Builder(); |
| |
| addHeadersFromRuleContext(builder, ruleContext); |
| addIncludesFromRuleContext(builder, ruleContext); |
| addSdkAttributesFromRuleContext(builder, ruleContext); |
| addCompileOptionsFromRuleContext(builder, ruleContext); |
| addModuleOptionsFromRuleContext(builder, ruleContext); |
| |
| return builder; |
| } |
| |
| /** |
| * Adds headers to be made available for dependents. |
| */ |
| public Builder addHdrs(NestedSet<Artifact> hdrs) { |
| this.hdrs.addTransitive(hdrs); |
| return this; |
| } |
| |
| /** |
| * Adds headers that cannot be compiled individually. |
| */ |
| public Builder addTextualHdrs(NestedSet<Artifact> textualHdrs) { |
| this.textualHdrs.addTransitive(textualHdrs); |
| return this; |
| } |
| |
| /** |
| * Adds include paths to be made available for compilation. |
| */ |
| public Builder addIncludes(NestedSet<PathFragment> includes) { |
| this.includes.addTransitive(includes); |
| return this; |
| } |
| |
| /** |
| * Adds paths for SDK includes. |
| */ |
| public Builder addSdkIncludes(NestedSet<PathFragment> sdkIncludes) { |
| this.sdkIncludes.addTransitive(sdkIncludes); |
| return this; |
| } |
| |
| /** |
| * Adds compile-time options. |
| */ |
| public Builder addCopts(Iterable<String> copts) { |
| this.copts.addAll(copts); |
| return this; |
| } |
| |
| /** |
| * Adds link-time options. |
| */ |
| public Builder addLinkopts(Iterable<String> linkopts) { |
| this.linkopts.addAll(linkopts); |
| return this; |
| } |
| |
| /** |
| * Adds clang module maps for direct dependencies of the rule. These are needed to generate |
| * module maps. |
| */ |
| public Builder addModuleMapsForDirectDeps(NestedSet<CppModuleMap> moduleMapsForDirectDeps) { |
| this.moduleMapsForDirectDeps.addTransitive(moduleMapsForDirectDeps); |
| return this; |
| } |
| |
| /** |
| * Adds SDK frameworks to link against. |
| */ |
| public Builder addSdkFrameworks(NestedSet<SdkFramework> sdkFrameworks) { |
| this.sdkFrameworks.addTransitive(sdkFrameworks); |
| return this; |
| } |
| |
| /** |
| * Adds SDK frameworks to be linked weakly. |
| */ |
| public Builder addWeakSdkFrameworks(NestedSet<SdkFramework> weakSdkFrameworks) { |
| this.weakSdkFrameworks.addTransitive(weakSdkFrameworks); |
| return this; |
| } |
| |
| /** |
| * Adds SDK Dylibs to link against. |
| */ |
| public Builder addSdkDylibs(NestedSet<String> sdkDylibs) { |
| this.sdkDylibs.addTransitive(sdkDylibs); |
| return this; |
| } |
| |
| /** |
| * Sets the package path from which to base the header search paths. |
| */ |
| public Builder setPackageFragment(PathFragment packageFragment) { |
| Preconditions.checkState( |
| !this.packageFragment.isPresent(), |
| "packageFragment is already set to %s", |
| this.packageFragment); |
| this.packageFragment = Optional.of(packageFragment); |
| return this; |
| } |
| |
| /** |
| * Enables the usage of clang modules maps during compilation. |
| */ |
| public Builder enableModules() { |
| this.enableModules = true; |
| return this; |
| } |
| |
| /** |
| * Builds a {@code CompilationAttributes} object. |
| */ |
| public CompilationAttributes build() { |
| return new CompilationAttributes( |
| this.hdrs.build(), |
| this.textualHdrs.build(), |
| this.includes.build(), |
| this.sdkIncludes.build(), |
| this.sdkFrameworks.build(), |
| this.weakSdkFrameworks.build(), |
| this.sdkDylibs.build(), |
| this.packageFragment, |
| this.copts.build(), |
| this.linkopts.build(), |
| this.moduleMapsForDirectDeps.build(), |
| this.enableModules); |
| } |
| |
| private static void addHeadersFromRuleContext(Builder builder, RuleContext ruleContext) { |
| if (ruleContext.attributes().has("hdrs", BuildType.LABEL_LIST)) { |
| NestedSetBuilder<Artifact> headers = NestedSetBuilder.stableOrder(); |
| for (Pair<Artifact, Label> header : CcCommon.getHeaders(ruleContext)) { |
| headers.add(header.first); |
| } |
| builder.addHdrs(headers.build()); |
| } |
| |
| if (ruleContext.attributes().has("textual_hdrs", BuildType.LABEL_LIST)) { |
| builder.addTextualHdrs( |
| PrerequisiteArtifacts.nestedSet(ruleContext, "textual_hdrs", Mode.TARGET)); |
| } |
| } |
| |
| private static void addIncludesFromRuleContext(Builder builder, RuleContext ruleContext) { |
| if (ruleContext.attributes().has("includes", Type.STRING_LIST)) { |
| NestedSetBuilder<PathFragment> includes = NestedSetBuilder.stableOrder(); |
| includes.addAll( |
| Iterables.transform( |
| ruleContext.attributes().get("includes", Type.STRING_LIST), |
| PathFragment.TO_PATH_FRAGMENT)); |
| builder.addIncludes(includes.build()); |
| } |
| |
| if (ruleContext.attributes().has("sdk_includes", Type.STRING_LIST)) { |
| NestedSetBuilder<PathFragment> sdkIncludes = NestedSetBuilder.stableOrder(); |
| sdkIncludes.addAll( |
| Iterables.transform( |
| ruleContext.attributes().get("sdk_includes", Type.STRING_LIST), |
| PathFragment.TO_PATH_FRAGMENT)); |
| builder.addSdkIncludes(sdkIncludes.build()); |
| } |
| } |
| |
| private static void addSdkAttributesFromRuleContext(Builder builder, RuleContext ruleContext) { |
| if (ruleContext.attributes().has("sdk_frameworks", Type.STRING_LIST)) { |
| NestedSetBuilder<SdkFramework> frameworks = NestedSetBuilder.stableOrder(); |
| // TODO(bazel-team): Move the inclusion of the default frameworks to CompilationSupport. |
| frameworks.addAll(ObjcRuleClasses.AUTOMATIC_SDK_FRAMEWORKS); |
| for (String explicit : ruleContext.attributes().get("sdk_frameworks", Type.STRING_LIST)) { |
| frameworks.add(new SdkFramework(explicit)); |
| } |
| builder.addSdkFrameworks(frameworks.build()); |
| } |
| |
| if (ruleContext.attributes().has("weak_sdk_frameworks", Type.STRING_LIST)) { |
| NestedSetBuilder<SdkFramework> weakFrameworks = NestedSetBuilder.stableOrder(); |
| for (String frameworkName : |
| ruleContext.attributes().get("weak_sdk_frameworks", Type.STRING_LIST)) { |
| weakFrameworks.add(new SdkFramework(frameworkName)); |
| } |
| builder.addWeakSdkFrameworks(weakFrameworks.build()); |
| } |
| |
| if (ruleContext.attributes().has("sdk_dylibs", Type.STRING_LIST)) { |
| NestedSetBuilder<String> sdkDylibs = NestedSetBuilder.stableOrder(); |
| sdkDylibs.addAll(ruleContext.attributes().get("sdk_dylibs", Type.STRING_LIST)); |
| builder.addSdkDylibs(sdkDylibs.build()); |
| } |
| } |
| |
| private static void addCompileOptionsFromRuleContext(Builder builder, RuleContext ruleContext) { |
| if (ruleContext.attributes().has("copts", Type.STRING_LIST)) { |
| builder.addCopts(ruleContext.getTokenizedStringListAttr("copts")); |
| } |
| |
| if (ruleContext.attributes().has("linkopts", Type.STRING_LIST)) { |
| builder.addLinkopts(ruleContext.getTokenizedStringListAttr("linkopts")); |
| } |
| } |
| |
| private static void addModuleOptionsFromRuleContext(Builder builder, RuleContext ruleContext) { |
| NestedSetBuilder<CppModuleMap> moduleMaps = NestedSetBuilder.stableOrder(); |
| ObjcConfiguration objcConfiguration = ObjcRuleClasses.objcConfiguration(ruleContext); |
| if (objcConfiguration.moduleMapsEnabled()) { |
| // Make sure all dependencies that have headers are included here. If a module map is |
| // missing, its private headers will be treated as public! |
| if (ruleContext.attributes().has("deps", BuildType.LABEL_LIST)) { |
| Iterable<ObjcProvider> providers = |
| ruleContext.getPrerequisites("deps", Mode.TARGET, ObjcProvider.class); |
| for (ObjcProvider provider : providers) { |
| moduleMaps.addTransitive(provider.get(TOP_LEVEL_MODULE_MAP)); |
| } |
| } |
| if (ruleContext.attributes().has("non_propagated_deps", BuildType.LABEL_LIST)) { |
| Iterable<ObjcProvider> providers = |
| ruleContext.getPrerequisites("non_propagated_deps", Mode.TARGET, ObjcProvider.class); |
| for (ObjcProvider provider : providers) { |
| moduleMaps.addTransitive(provider.get(TOP_LEVEL_MODULE_MAP)); |
| } |
| } |
| } |
| |
| builder.addModuleMapsForDirectDeps(moduleMaps.build()); |
| |
| PathFragment packageFragment = |
| ruleContext.getLabel().getPackageIdentifier().getSourceRoot(); |
| if (packageFragment != null) { |
| builder.setPackageFragment(packageFragment); |
| } |
| |
| if (ruleContext.attributes().has("enable_modules", Type.BOOLEAN) |
| && ruleContext.attributes().get("enable_modules", Type.BOOLEAN)) { |
| builder.enableModules(); |
| } |
| } |
| } |
| |
| private final NestedSet<Artifact> hdrs; |
| private final NestedSet<Artifact> textualHdrs; |
| private final NestedSet<PathFragment> includes; |
| private final NestedSet<PathFragment> sdkIncludes; |
| private final NestedSet<SdkFramework> sdkFrameworks; |
| private final NestedSet<SdkFramework> weakSdkFrameworks; |
| private final NestedSet<String> sdkDylibs; |
| private final Optional<PathFragment> packageFragment; |
| private final ImmutableList<String> copts; |
| private final ImmutableList<String> linkopts; |
| private final NestedSet<CppModuleMap> moduleMapsForDirectDeps; |
| private final boolean enableModules; |
| |
| private CompilationAttributes( |
| NestedSet<Artifact> hdrs, |
| NestedSet<Artifact> textualHdrs, |
| NestedSet<PathFragment> includes, |
| NestedSet<PathFragment> sdkIncludes, |
| NestedSet<SdkFramework> sdkFrameworks, |
| NestedSet<SdkFramework> weakSdkFrameworks, |
| NestedSet<String> sdkDylibs, |
| Optional<PathFragment> packageFragment, |
| ImmutableList<String> copts, |
| ImmutableList<String> linkopts, |
| NestedSet<CppModuleMap> moduleMapsForDirectDeps, |
| boolean enableModules) { |
| this.hdrs = hdrs; |
| this.textualHdrs = textualHdrs; |
| this.includes = includes; |
| this.sdkIncludes = sdkIncludes; |
| this.sdkFrameworks = sdkFrameworks; |
| this.weakSdkFrameworks = weakSdkFrameworks; |
| this.sdkDylibs = sdkDylibs; |
| this.packageFragment = packageFragment; |
| this.copts = copts; |
| this.linkopts = linkopts; |
| this.moduleMapsForDirectDeps = moduleMapsForDirectDeps; |
| this.enableModules = enableModules; |
| } |
| |
| /** |
| * Returns the headers to be made available for dependents. |
| */ |
| public NestedSet<Artifact> hdrs() { |
| return this.hdrs; |
| } |
| |
| /** |
| * Returns the headers that cannot be compiled individually. |
| */ |
| public NestedSet<Artifact> textualHdrs() { |
| return this.textualHdrs; |
| } |
| |
| /** |
| * Returns the include paths to be made available for compilation. |
| */ |
| public NestedSet<PathFragment> includes() { |
| return this.includes; |
| } |
| |
| /** |
| * Returns the paths for SDK includes. |
| */ |
| public NestedSet<PathFragment> sdkIncludes() { |
| return this.sdkIncludes; |
| } |
| |
| /** |
| * Returns the SDK frameworks to link against. |
| */ |
| public NestedSet<SdkFramework> sdkFrameworks() { |
| return this.sdkFrameworks; |
| } |
| |
| /** |
| * Returns the SDK frameworks to be linked weakly. |
| */ |
| public NestedSet<SdkFramework> weakSdkFrameworks() { |
| return this.weakSdkFrameworks; |
| } |
| |
| /** |
| * Returns the SDK Dylibs to link against. |
| */ |
| public NestedSet<String> sdkDylibs() { |
| return this.sdkDylibs; |
| } |
| |
| /** |
| * Returns the exec paths of all header search paths that should be added to this target and |
| * dependers on this target, obtained from the {@code includes} attribute. |
| */ |
| public NestedSet<PathFragment> headerSearchPaths(PathFragment genfilesFragment) { |
| NestedSetBuilder<PathFragment> paths = NestedSetBuilder.stableOrder(); |
| if (packageFragment.isPresent()) { |
| List<PathFragment> rootFragments = |
| ImmutableList.of( |
| packageFragment.get(), genfilesFragment.getRelative(packageFragment.get())); |
| |
| Iterable<PathFragment> relativeIncludes = |
| Iterables.filter(includes(), Predicates.not(PathFragment.IS_ABSOLUTE)); |
| for (PathFragment include : relativeIncludes) { |
| for (PathFragment rootFragment : rootFragments) { |
| paths.add(rootFragment.getRelative(include).normalize()); |
| } |
| } |
| } |
| return paths.build(); |
| } |
| |
| /** |
| * Returns the compile-time options. |
| */ |
| public ImmutableList<String> copts() { |
| return this.copts; |
| } |
| |
| /** |
| * Returns the link-time options. |
| */ |
| public ImmutableList<String> linkopts() { |
| return this.linkopts; |
| } |
| |
| /** |
| * Returns the clang module maps of direct dependencies of this rule. These are needed to generate |
| * this rule's module map. |
| */ |
| public NestedSet<CppModuleMap> moduleMapsForDirectDeps() { |
| return this.moduleMapsForDirectDeps; |
| } |
| |
| /** |
| * Returns whether this target uses language features that require clang modules, such as |
| * {@literal @}import. |
| */ |
| public boolean enableModules() { |
| return this.enableModules; |
| } |
| } |