blob: 6f3c22970b36f33e153b0845d0bbc1947b50916f [file] [log] [blame]
// Copyright 2016 The Tulsi 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.
import Foundation
/// Models the label and type of a single supported Bazel target.
/// See http://bazel.build/docs/build-ref.html#targets.
public class RuleInfo: Equatable, Hashable, CustomDebugStringConvertible {
public let label: BuildLabel
public let type: String
/// Set of BuildLabels referencing targets that are required by this RuleInfo. For example, test
/// hosts for XCTest targets.
public let linkedTargetLabels: Set<BuildLabel>
public var hashValue: Int {
return label.hashValue ^ type.hashValue
}
public var debugDescription: String {
return "\(Swift.type(of: self))(\(label) \(type))"
}
init(label: BuildLabel, type: String, linkedTargetLabels: Set<BuildLabel>) {
self.label = label
self.type = type
self.linkedTargetLabels = linkedTargetLabels
}
func equals(_ other: RuleInfo) -> Bool {
guard Swift.type(of: self) == Swift.type(of: other) else {
return false
}
return self.type == other.type && self.label == other.label
}
}
/// Encapsulates data about a file that may be a Bazel input or output.
public class BazelFileInfo: Equatable, Hashable, CustomDebugStringConvertible {
public enum TargetType: Int {
case sourceFile
case generatedFile
}
/// The path to this file relative to rootPath.
public let subPath: String
/// The root of this file's path (typically used to indicate the path to a generated file's root).
public let rootPath: String
/// The type of this file.
public let targetType: TargetType
/// Whether or not this file object is a directory.
public let isDirectory: Bool
public lazy var fullPath: String = { [unowned self] in
return NSString.path(withComponents: [self.rootPath, self.subPath])
}()
public lazy var uti: String? = { [unowned self] in
return self.subPath.pbPathUTI
}()
public lazy var hashValue: Int = { [unowned self] in
return self.subPath.hashValue &+
self.rootPath.hashValue &+
self.targetType.hashValue &+
self.isDirectory.hashValue
}()
init?(info: AnyObject?) {
guard let info = info as? [String: AnyObject] else {
return nil
}
guard let subPath = info["path"] as? String,
let isSourceFile = info["src"] as? Bool else {
assertionFailure("Aspect provided a file info dictionary but was missing required keys")
return nil
}
self.subPath = subPath
if let rootPath = info["root"] as? String {
// Patch up
self.rootPath = rootPath
} else {
self.rootPath = ""
}
self.targetType = isSourceFile ? .sourceFile : .generatedFile
self.isDirectory = info["is_dir"] as? Bool ?? false
}
init(rootPath: String, subPath: String, isDirectory: Bool, targetType: TargetType) {
self.rootPath = rootPath
self.subPath = subPath
self.isDirectory = isDirectory
self.targetType = targetType
}
// MARK: - CustomDebugStringConvertible
public lazy var debugDescription: String = { [unowned self] in
return "{\(self.fullPath) \(self.isDirectory ? "<DIR> " : "")\(self.targetType)}"
}()
}
public func ==(lhs: BazelFileInfo, rhs: BazelFileInfo) -> Bool {
return lhs.targetType == rhs.targetType &&
lhs.rootPath == rhs.rootPath &&
lhs.subPath == rhs.subPath &&
lhs.isDirectory == rhs.isDirectory
}
/// Models the full metadata of a single supported Bazel target.
/// See http://bazel.build/docs/build-ref.html#targets.
public final class RuleEntry: RuleInfo {
// Include paths are represented by a string and a boolean indicating whether they should be
// searched recursively or not.
public typealias IncludePath = (String, Bool)
/// Mapping of BUILD file type to Xcode Target type for non-bundled types.
static let BuildTypeToTargetType = [
"cc_binary": PBXTarget.ProductType.Application,
"cc_library": PBXTarget.ProductType.StaticLibrary,
"cc_test": PBXTarget.ProductType.Tool,
// macos_command_line_application is not a bundled type in our rules as it does not contain
// any resources, so we must explicitly list it here.
"macos_command_line_application": PBXTarget.ProductType.Tool,
"objc_library": PBXTarget.ProductType.StaticLibrary,
"swift_library": PBXTarget.ProductType.StaticLibrary,
]
/// Keys for a RuleEntry's attributes map. Definitions may be found in the Bazel Build
/// Encyclopedia (see http://bazel.build/docs/be/overview.html).
// Note: This set of must be kept in sync with the tulsi_aspects aspect.
public enum Attribute: String {
case bridging_header
// Contains defines that were specified by the user on the commandline or are built into
// Bazel itself.
case compiler_defines
case copts
case datamodels
case enable_modules
case has_swift_dependency
case has_swift_info
case launch_storyboard
case pch
case swift_language_version
case swift_toolchain
case swiftc_opts
// Contains various files that are used as part of the build process but need no special
// handling in the generated Xcode project. For example, asset_catalog, storyboard, and xibs
// attributes all end up as supporting_files.
case supporting_files
// For the apple_unit_test and apple_ui_test rules, contains a label reference to the .xctest
// bundle packaging target.
case test_bundle
// For the apple_unit_test and apple_ui_test rules, contains a label reference to the
// ios_application target to be used as the test host when running the tests.
case test_host
}
/// Bazel attributes for this rule (e.g., "binary": <some label> on an ios_application).
public let attributes: [Attribute: AnyObject]
/// Artifacts produced by Bazel when this rule is built.
public let artifacts: [BazelFileInfo]
/// Objective-C defines to be applied to this rule by Bazel.
public let objcDefines: [String]?
/// Swift defines to be applied to this rule by Bazel.
public let swiftDefines: [String]?
/// Source files associated with this rule.
public let sourceFiles: [BazelFileInfo]
/// Non-ARC source files associated with this rule.
public let nonARCSourceFiles: [BazelFileInfo]
/// Paths to directories that will include header files.
public let includePaths: [IncludePath]?
/// Set of the labels that this rule depends on.
public let dependencies: Set<BuildLabel>
/// Set of the labels that this test rule's binary depends on.
public let testDependencies: Set<BuildLabel>
/// Set of ios_application extension labels that this rule utilizes.
public let extensions: Set<BuildLabel>
/// .framework bundles provided by this rule.
public let frameworkImports: [BazelFileInfo]
/// List of implicit artifacts that are generated by this rule.
public let secondaryArtifacts: [BazelFileInfo]
/// The Swift language version used by this target.
public let swiftLanguageVersion: String?
/// The swift toolchain argument used by this target.
public let swiftToolchain: String?
/// List containing the transitive swiftmodules on which this rule depends.
public let swiftTransitiveModules: [BazelFileInfo]
/// List containing the transitive ObjC modulemaps on which this rule depends.
public let objCModuleMaps: [BazelFileInfo]
/// Module name to use in Xcode instead of the default.
public let moduleName: String?
/// The deployment platform target for this target.
public let deploymentTarget: DeploymentTarget?
/// Set of labels that this rule depends on but does not require.
/// TODO(b/71904309): Remove this once test_suite fetching via Aspect is stable.
// NOTE(abaire): This is a hack used for test_suite rules, where the possible expansions retrieved
// via queries are filtered by the existence of the selected labels extracted via the normal
// aspect path. Ideally the aspect would be able to directly express the relationship between the
// test_suite and the test rules themselves, but that expansion is done prior to the application
// of the aspect.
public var weakDependencies = Set<BuildLabel>()
/// Set of labels that this test_suite depends on. If this target is not a test_suite, returns
/// an empty set. This maps directly to the `tests` attribute of the test_suite.
public var testSuiteDependencies: Set<BuildLabel> {
guard type == "test_suite" else { return Set() }
// Legacy support for expansion of test_suite via a Bazel query. If a Bazel query is used,
// `dependencies` will be empty and `weakDependencies` will contain the test_suite's
// dependencies. Otherwise, `dependencies` will contain the test_suite's dependencies.
guard dependencies.isEmpty else { return dependencies }
return weakDependencies
}
/// The BUILD file that this rule was defined in.
public let buildFilePath: String?
// The CFBundleIdentifier associated with the target for this rule, if any.
public let bundleID: String?
/// The bundle name associated with the target for this rule, if any.
public let bundleName: String?
/// The product type for this rule (only for targets With AppleBundleInfo).
let productType: PBXTarget.ProductType?
/// The CFBundleIdentifier of the watchOS extension target associated with this rule, if any.
public let extensionBundleID: String?
/// The NSExtensionPointIdentifier of the extension associated with this rule, if any.
public let extensionType: String?
/// Xcode version used during the aspect run. Only set for bundled and runnable targets.
public let xcodeVersion: String?
/// Returns the set of non-versioned artifacts that are not source files.
public var normalNonSourceArtifacts: [BazelFileInfo] {
var artifacts = [BazelFileInfo]()
if let description = attributes[.launch_storyboard] as? [String: AnyObject],
let fileTarget = BazelFileInfo(info: description as AnyObject?) {
artifacts.append(fileTarget)
}
if let fileTargets = parseFileDescriptionListAttribute(.supporting_files) {
artifacts.append(contentsOf: fileTargets)
}
return artifacts
}
/// Returns the set of artifacts for which a versioned group should be created in the generated
/// Xcode project.
public var versionedNonSourceArtifacts: [BazelFileInfo] {
if let fileTargets = parseFileDescriptionListAttribute(.datamodels) {
return fileTargets
}
return []
}
/// The full set of input and output artifacts for this rule.
public var projectArtifacts: [BazelFileInfo] {
var artifacts = sourceFiles
artifacts.append(contentsOf: nonARCSourceFiles)
artifacts.append(contentsOf: frameworkImports)
artifacts.append(contentsOf: normalNonSourceArtifacts)
artifacts.append(contentsOf: versionedNonSourceArtifacts)
return artifacts
}
private(set) lazy var pbxTargetType: PBXTarget.ProductType? = { [unowned self] in
if let productType = self.productType {
return productType
}
return RuleEntry.BuildTypeToTargetType[self.type]
}()
/// Returns the value to be used as the Xcode SDKROOT for the build target generated for this
/// RuleEntry.
private(set) lazy var XcodeSDKRoot: String? = { [unowned self] in
guard type != "cc_binary" && type != "cc_test" else {
return PlatformType.macos.deviceSDK
}
if let platformType = self.deploymentTarget?.platform {
return platformType.deviceSDK
}
return PlatformType.ios.deviceSDK
}()
init(label: BuildLabel,
type: String,
attributes: [String: AnyObject],
artifacts: [BazelFileInfo] = [],
sourceFiles: [BazelFileInfo] = [],
nonARCSourceFiles: [BazelFileInfo] = [],
dependencies: Set<BuildLabel> = Set(),
testDependencies: Set<BuildLabel> = Set(),
frameworkImports: [BazelFileInfo] = [],
secondaryArtifacts: [BazelFileInfo] = [],
weakDependencies: Set<BuildLabel>? = nil,
extensions: Set<BuildLabel>? = nil,
bundleID: String? = nil,
bundleName: String? = nil,
productType: PBXTarget.ProductType? = nil,
extensionBundleID: String? = nil,
platformType: String? = nil,
osDeploymentTarget: String? = nil,
buildFilePath: String? = nil,
objcDefines: [String]? = nil,
swiftDefines: [String]? = nil,
includePaths: [IncludePath]? = nil,
swiftLanguageVersion: String? = nil,
swiftToolchain: String? = nil,
swiftTransitiveModules: [BazelFileInfo] = [],
objCModuleMaps: [BazelFileInfo] = [],
moduleName: String? = nil,
extensionType: String? = nil,
xcodeVersion: String? = nil) {
var checkedAttributes = [Attribute: AnyObject]()
for (key, value) in attributes {
guard let checkedKey = Attribute(rawValue: key) else {
print("Tulsi rule \(label.value) - Ignoring unknown attribute key \(key)")
assertionFailure("Unknown attribute key \(key)")
continue
}
checkedAttributes[checkedKey] = value
}
self.attributes = checkedAttributes
let parsedPlatformType: PlatformType?
if let platformTypeStr = platformType {
parsedPlatformType = PlatformType(rawValue: platformTypeStr)
} else {
parsedPlatformType = nil
}
self.artifacts = artifacts
self.sourceFiles = sourceFiles
self.nonARCSourceFiles = nonARCSourceFiles
self.dependencies = dependencies
self.testDependencies = testDependencies
self.frameworkImports = frameworkImports
self.secondaryArtifacts = secondaryArtifacts
if let weakDependencies = weakDependencies {
self.weakDependencies = weakDependencies
}
if let extensions = extensions {
self.extensions = extensions
} else {
self.extensions = Set()
}
self.bundleID = bundleID
self.bundleName = bundleName
self.productType = productType
self.extensionBundleID = extensionBundleID
var deploymentTarget: DeploymentTarget? = nil
if let platform = parsedPlatformType,
let osVersion = osDeploymentTarget {
deploymentTarget = DeploymentTarget(platform: platform, osVersion: osVersion)
}
self.deploymentTarget = deploymentTarget
self.buildFilePath = buildFilePath
self.objcDefines = objcDefines
self.moduleName = moduleName
self.swiftDefines = swiftDefines
self.includePaths = includePaths
self.swiftLanguageVersion = swiftLanguageVersion
self.swiftToolchain = swiftToolchain
self.swiftTransitiveModules = swiftTransitiveModules
self.xcodeVersion = xcodeVersion
// Swift targets may have a generated Objective-C module map for their Swift generated header.
// Unfortunately, this breaks Xcode's indexing (it doesn't really make sense to ask SourceKit
// to index some source files in a module while at the same time giving it a compiled version
// of the same module), so we must exclude it.
//
// We must do the same thing for tests, except that it may apply to multiple modules as we
// combine sources from potentially multiple targets into one test target.
let targetsToAvoid = testDependencies + [label]
let moduleMapsToAvoid = targetsToAvoid.compactMap { (targetLabel: BuildLabel) -> String? in
if let fileName = targetLabel.asFileName {
return "\(fileName).modulemaps/module.modulemap"
}
return nil
}
if !moduleMapsToAvoid.isEmpty {
self.objCModuleMaps = objCModuleMaps.filter { moduleMapFileInfo in
let moduleMapPath = moduleMapFileInfo.fullPath
for mapToAvoid in moduleMapsToAvoid {
if moduleMapPath.hasSuffix(mapToAvoid) {
return false
}
}
return true
}
} else {
self.objCModuleMaps = objCModuleMaps
}
self.extensionType = extensionType
var linkedTargetLabels = Set<BuildLabel>()
if let hostLabelString = self.attributes[.test_host] as? String {
linkedTargetLabels.insert(BuildLabel(hostLabelString))
}
super.init(label: label, type: type, linkedTargetLabels: linkedTargetLabels)
}
convenience init(label: String,
type: String,
attributes: [String: AnyObject],
artifacts: [BazelFileInfo] = [],
sourceFiles: [BazelFileInfo] = [],
nonARCSourceFiles: [BazelFileInfo] = [],
dependencies: Set<BuildLabel> = Set(),
testDependencies: Set<BuildLabel> = Set(),
frameworkImports: [BazelFileInfo] = [],
secondaryArtifacts: [BazelFileInfo] = [],
weakDependencies: Set<BuildLabel>? = nil,
extensions: Set<BuildLabel>? = nil,
bundleID: String? = nil,
bundleName: String? = nil,
productType: PBXTarget.ProductType? = nil,
extensionBundleID: String? = nil,
platformType: String? = nil,
osDeploymentTarget: String? = nil,
buildFilePath: String? = nil,
objcDefines: [String]? = nil,
swiftDefines: [String]? = nil,
includePaths: [IncludePath]? = nil,
swiftLanguageVersion: String? = nil,
swiftToolchain: String? = nil,
swiftTransitiveModules: [BazelFileInfo] = [],
objCModuleMaps: [BazelFileInfo] = [],
moduleName: String? = nil,
extensionType: String? = nil,
xcodeVersion: String? = nil) {
self.init(label: BuildLabel(label),
type: type,
attributes: attributes,
artifacts: artifacts,
sourceFiles: sourceFiles,
nonARCSourceFiles: nonARCSourceFiles,
dependencies: dependencies,
testDependencies: testDependencies,
frameworkImports: frameworkImports,
secondaryArtifacts: secondaryArtifacts,
weakDependencies: weakDependencies,
extensions: extensions,
bundleID: bundleID,
bundleName: bundleName,
productType: productType,
extensionBundleID: extensionBundleID,
platformType: platformType,
osDeploymentTarget: osDeploymentTarget,
buildFilePath: buildFilePath,
objcDefines: objcDefines,
swiftDefines: swiftDefines,
includePaths: includePaths,
swiftLanguageVersion: swiftLanguageVersion,
swiftToolchain: swiftToolchain,
swiftTransitiveModules: swiftTransitiveModules,
objCModuleMaps: objCModuleMaps,
moduleName: moduleName,
extensionType: extensionType,
xcodeVersion: xcodeVersion)
}
// MARK: Private methods
private func parseFileDescriptionListAttribute(_ attribute: RuleEntry.Attribute) -> [BazelFileInfo]? {
guard let descriptions = attributes[attribute] as? [[String: AnyObject]] else {
return nil
}
var fileTargets = [BazelFileInfo]()
for description in descriptions {
guard let target = BazelFileInfo(info: description as AnyObject?) else {
assertionFailure("Failed to resolve file description to a file target")
continue
}
fileTargets.append(target)
}
return fileTargets
}
override func equals(_ other: RuleInfo) -> Bool {
guard super.equals(other), let entry = other as? RuleEntry else {
return false
}
return deploymentTarget == entry.deploymentTarget
}
}
// MARK: - Equatable
public func ==(lhs: RuleInfo, rhs: RuleInfo) -> Bool {
return lhs.equals(rhs)
}