Rename ValueGraph to Graph (#3083)

CHANGELOG.md

@@ -12,6 +12,7 @@ Please, check out guidelines: https://keepachangelog.com/en/1.0.0/
 
 ### Changed
 
+- Renamed `ValueGraph` to `Graph` [#3083](https://github.com/tuist/tuist/pull/3083) by [@fortmarek](https://github.com/fortmarek)
 - Fixed a typo on the `tuist generate` command documentation for argument --skip-test-targets. [#3069](https://github.com/tuist/tuist/pull/3069) by [@mrcloud](https://github.com/mrcloud)
 - **breaking** The `tuist dependencies` command requires the `Carthage` version to be at least `0.37.0`. [#3043](https://github.com/tuist/tuist/pull/3043) by [@laxmorek](https://github.com/laxmorek)
 

Sources/TuistAutomation/Utilities/BuildGraphInspector.swift

@@ -20,12 +20,12 @@ public protocol BuildGraphInspecting {
     /// - Parameters:
     ///   - scheme: Scheme in which to look up the target.
     ///   - graphTraverser: GraphTraversing traverser.
-    func buildableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget?
+    func buildableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget?
 
     ///  From the list of testable targets of the given scheme, it returns the first one.
     /// - Parameters:
     ///   - scheme: Scheme in which to look up the target.
-    func testableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget?
+    func testableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget?
 
     /// Given a graphTraverser, it returns a list of buildable schemes.
     func buildableSchemes(graphTraverser: GraphTraversing) -> [Scheme]
@@ -43,7 +43,7 @@ public protocol BuildGraphInspecting {
     /// - Parameters:
     ///   - scheme: Scheme in which to look up the target.
     ///   - graphTraverser: GraphTraversing traverser.
-    func runnableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget?
+    func runnableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget?
 
     /// Given a graphTraverser, it returns a list of runnable schemes.
     func runnableSchemes(graphTraverser: GraphTraversing) -> [Scheme]
@@ -85,7 +85,7 @@ public final class BuildGraphInspector: BuildGraphInspecting {
         return arguments
     }
 
-    public func buildableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget? {
+    public func buildableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget? {
         guard
             scheme.buildAction?.targets.isEmpty == false,
             let buildTarget = scheme.buildAction?.targets.first
@@ -99,7 +99,7 @@ public final class BuildGraphInspector: BuildGraphInspecting {
         )
     }
 
-    public func testableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget? {
+    public func testableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget? {
         guard let testTarget = scheme.testAction?.targets.first else { return nil }
         return graphTraverser.target(path: testTarget.target.projectPath, name: testTarget.target.name)
     }
@@ -135,7 +135,7 @@ public final class BuildGraphInspector: BuildGraphInspecting {
             .sorted(by: { $0.name < $1.name })
     }
 
-    public func runnableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget? {
+    public func runnableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget? {
         guard let runTarget = scheme.runAction?.executable else { return nil }
         return graphTraverser.target(
             path: runTarget.projectPath,

Sources/TuistAutomation/Utilities/TargetBuilder.swift

@@ -15,7 +15,7 @@ public protocol TargetBuilding {
     ///   - configuration: The configuration to use while building the scheme.
     ///   - buildOutputPath: An optional path to copy the build products to.
     func buildTarget(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         workspacePath: AbsolutePath,
         schemeName: String,
         clean: Bool,
@@ -63,7 +63,7 @@ public final class TargetBuilder: TargetBuilding {
     }
 
     public func buildTarget(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         workspacePath: AbsolutePath,
         schemeName: String,
         clean: Bool,

Sources/TuistAutomation/Utilities/TargetRunner.swift

@@ -18,7 +18,7 @@ public protocol TargetRunning {
     ///   - deviceName: The name of the simulator device to run the target on, if none provided uses a default device.
     ///   - arguments: Arguments to forward to the runnable target when running.
     func runTarget(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         workspacePath: AbsolutePath,
         schemeName: String,
         configuration: String?,
@@ -72,7 +72,7 @@ public final class TargetRunner: TargetRunning {
     }
 
     public func runTarget(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         workspacePath: AbsolutePath,
         schemeName: String,
         configuration: String?,
@@ -132,7 +132,7 @@ public final class TargetRunner: TargetRunning {
     }
 
     private func runApp(
-        target: ValueGraphTarget,
+        target: GraphTarget,
         schemeName: String,
         configuration: String,
         appPath: AbsolutePath,

Sources/TuistAutomationTesting/Utilities/MockBuildGraphInspector.swift

@@ -13,12 +13,12 @@ public final class MockBuildGraphInspector: BuildGraphInspecting {
         workspacePathStub?(directory) ?? nil
     }
 
-    public var buildableTargetStub: ((Scheme, GraphTraversing) -> ValueGraphTarget?)?
-    public func buildableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget? {
+    public var buildableTargetStub: ((Scheme, GraphTraversing) -> GraphTarget?)?
+    public func buildableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget? {
         if let buildableTargetStub = buildableTargetStub {
             return buildableTargetStub(scheme, graphTraverser)
         } else {
-            return ValueGraphTarget.test()
+            return GraphTarget.test()
         }
     }
 
@@ -45,12 +45,12 @@ public final class MockBuildGraphInspector: BuildGraphInspecting {
         }
     }
 
-    public var testableTargetStub: ((Scheme, GraphTraversing) -> ValueGraphTarget?)?
-    public func testableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget? {
+    public var testableTargetStub: ((Scheme, GraphTraversing) -> GraphTarget?)?
+    public func testableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget? {
         if let testableTargetStub = testableTargetStub {
             return testableTargetStub(scheme, graphTraverser)
         } else {
-            return ValueGraphTarget.test()
+            return GraphTarget.test()
         }
     }
 
@@ -68,8 +68,8 @@ public final class MockBuildGraphInspector: BuildGraphInspecting {
         testSchemesStub?(graphTraverser) ?? []
     }
 
-    public var runnableTargetStub: ((Scheme, GraphTraversing) -> ValueGraphTarget?)?
-    public func runnableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> ValueGraphTarget? {
+    public var runnableTargetStub: ((Scheme, GraphTraversing) -> GraphTarget?)?
+    public func runnableTarget(scheme: Scheme, graphTraverser: GraphTraversing) -> GraphTarget? {
         runnableTargetStub?(scheme, graphTraverser)
     }
 

Sources/TuistAutomationTesting/Utilities/MockTargetBuilder.swift

@@ -6,9 +6,9 @@ import TuistGraph
 public final class MockTargetBuilder: TargetBuilding {
     public init() {}
 
-    public var buildTargetStub: ((ValueGraphTarget, AbsolutePath, String, Bool, String?, AbsolutePath?) throws -> Void)?
+    public var buildTargetStub: ((GraphTarget, AbsolutePath, String, Bool, String?, AbsolutePath?) throws -> Void)?
     public func buildTarget(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         workspacePath: AbsolutePath,
         schemeName: String,
         clean: Bool,

Sources/TuistAutomationTesting/Utilities/MockTargetRunner.swift

@@ -6,9 +6,9 @@ import TuistGraph
 public final class MockTargetRunner: TargetRunning {
     public init() {}
 
-    public var runTargetStub: ((ValueGraphTarget, AbsolutePath, String, String?, Version?, Version?, String?, [String]) throws -> Void)?
+    public var runTargetStub: ((GraphTarget, AbsolutePath, String, String?, Version?, Version?, String?, [String]) throws -> Void)?
     public func runTarget(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         workspacePath: AbsolutePath,
         schemeName: String,
         configuration: String?,

Sources/TuistCache/ContentHashing/CacheGraphContentHasher.swift

@@ -11,10 +11,10 @@ public protocol CacheGraphContentHashing {
     ///     - cacheProfile: Cache profile currently being used
     ///     - cacheOutputType: Output type of cache -> makes a different hash for a different output type
     func contentHashes(
-        for graph: ValueGraph,
+        for graph: Graph,
         cacheProfile: TuistGraph.Cache.Profile,
         cacheOutputType: CacheOutputType
-    ) throws -> [ValueGraphTarget: String]
+    ) throws -> [GraphTarget: String]
 }
 
 public final class CacheGraphContentHasher: CacheGraphContentHashing {
@@ -43,11 +43,11 @@ public final class CacheGraphContentHasher: CacheGraphContentHashing {
     }
 
     public func contentHashes(
-        for graph: ValueGraph,
+        for graph: Graph,
         cacheProfile: TuistGraph.Cache.Profile,
         cacheOutputType: CacheOutputType
-    ) throws -> [ValueGraphTarget: String] {
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+    ) throws -> [GraphTarget: String] {
+        let graphTraverser = GraphTraverser(graph: graph)
         return try graphContentHasher.contentHashes(
             for: graph,
             filter: { filterHashTarget($0, graphTraverser: graphTraverser) },
@@ -59,7 +59,7 @@ public final class CacheGraphContentHasher: CacheGraphContentHashing {
     }
 
     private func filterHashTarget(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         graphTraverser: GraphTraversing
     ) -> Bool {
         let isFramework = target.target.product == .framework || target.target.product == .staticFramework

Sources/TuistCache/ContentHashing/GraphContentHasher.swift

@@ -11,10 +11,10 @@ public protocol GraphContentHashing {
     ///     - filter: If `true`, `TargetNode` is hashed, otherwise it is skipped
     ///     - additionalStrings: Additional strings to be used when hashing graph
     func contentHashes(
-        for graph: ValueGraph,
-        filter: (ValueGraphTarget) -> Bool,
+        for graph: Graph,
+        filter: (GraphTarget) -> Bool,
         additionalStrings: [String]
-    ) throws -> [ValueGraphTarget: String]
+    ) throws -> [GraphTarget: String]
 }
 
 public extension GraphContentHashing {
@@ -24,10 +24,10 @@ public extension GraphContentHashing {
     ///     - filter: If `true`, `TargetNode` is hashed, otherwise it is skipped
     ///     - additionalStrings: Additional strings to be used when hashing graph
     func contentHashes(
-        for graph: ValueGraph,
-        filter: (ValueGraphTarget) -> Bool = { _ in true },
+        for graph: Graph,
+        filter: (GraphTarget) -> Bool = { _ in true },
         additionalStrings: [String] = []
-    ) throws -> [ValueGraphTarget: String] {
+    ) throws -> [GraphTarget: String] {
         try contentHashes(
             for: graph,
             filter: filter,
@@ -56,13 +56,13 @@ public final class GraphContentHasher: GraphContentHashing {
     // MARK: - GraphContentHashing
 
     public func contentHashes(
-        for graph: ValueGraph,
-        filter: (ValueGraphTarget) -> Bool,
+        for graph: Graph,
+        filter: (GraphTarget) -> Bool,
         additionalStrings: [String]
-    ) throws -> [ValueGraphTarget: String] {
-        let graphTraverser = ValueGraphTraverser(graph: graph)
-        var visitedNodes: [ValueGraphTarget: Bool] = [:]
-        let hashableTargets = graphTraverser.allTargets().compactMap { target -> ValueGraphTarget? in
+    ) throws -> [GraphTarget: String] {
+        let graphTraverser = GraphTraverser(graph: graph)
+        var visitedNodes: [GraphTarget: Bool] = [:]
+        let hashableTargets = graphTraverser.allTargets().compactMap { target -> GraphTarget? in
             if isHashable(
                 target,
                 graphTraverser: graphTraverser,
@@ -86,10 +86,10 @@ public final class GraphContentHasher: GraphContentHashing {
     // MARK: - Private
 
     private func isHashable(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         graphTraverser: GraphTraversing,
-        visited: inout [ValueGraphTarget: Bool],
-        filter: (ValueGraphTarget) -> Bool
+        visited: inout [GraphTarget: Bool],
+        filter: (GraphTarget) -> Bool
     ) -> Bool {
         guard filter(target) else {
             visited[target] = false

Sources/TuistCache/ContentHashing/TargetContentHasher.swift

@@ -5,8 +5,8 @@ import TuistGraph
 import TuistSupport
 
 public protocol TargetContentHashing {
-    func contentHash(for target: ValueGraphTarget) throws -> String
-    func contentHash(for target: ValueGraphTarget, additionalStrings: [String]) throws -> String
+    func contentHash(for target: GraphTarget) throws -> String
+    func contentHash(for target: GraphTarget, additionalStrings: [String]) throws -> String
 }
 
 /// `TargetContentHasher`
@@ -70,11 +70,11 @@ public final class TargetContentHasher: TargetContentHashing {
 
     // MARK: - TargetContentHashing
 
-    public func contentHash(for target: ValueGraphTarget) throws -> String {
+    public func contentHash(for target: GraphTarget) throws -> String {
         try contentHash(for: target, additionalStrings: [])
     }
 
-    public func contentHash(for target: ValueGraphTarget, additionalStrings: [String]) throws -> String {
+    public func contentHash(for target: GraphTarget, additionalStrings: [String]) throws -> String {
         try contentHash(for: target.target, additionalStrings: additionalStrings)
     }
 

Sources/TuistCache/GraphMappers/CacheGraphMutator.swift

@@ -13,7 +13,7 @@ protocol CacheGraphMutating {
     ///   - graph: Dependency graph.
     ///   - precompiledFrameworks: Dictionary that maps targets with the paths to their cached `.framework`s or `.xcframework`s.
     ///   - source: Contains a list of targets that won't be replaced with their pre-compiled version from the cache.
-    func map(graph: ValueGraph, precompiledFrameworks: [ValueGraphTarget: AbsolutePath], sources: Set<String>) throws -> ValueGraph
+    func map(graph: Graph, precompiledFrameworks: [GraphTarget: AbsolutePath], sources: Set<String>) throws -> Graph
 }
 
 class CacheGraphMutator: CacheGraphMutating {
@@ -47,22 +47,22 @@ class CacheGraphMutator: CacheGraphMutating {
     ///   - precompiledFrameworks: Dictionary that maps targets with the paths to their cached `.framework`s or `.xcframework`s.
     ///   - source: Contains a list of targets that won't be replaced with their pre-compiled version from the cache.
     func map(
-        graph: ValueGraph,
-        precompiledFrameworks: [ValueGraphTarget: AbsolutePath],
+        graph: Graph,
+        precompiledFrameworks: [GraphTarget: AbsolutePath],
         sources: Set<String>
-    ) throws -> ValueGraph {
+    ) throws -> Graph {
         var graph = graph
-        let graphTraverser = ValueGraphTraverser(graph: graph)
-        var visitedPrecompiledFrameworkPaths: [ValueGraphTarget: VisitedPrecompiledFramework?] = [:]
-        var loadedPrecompiledDependencies: [AbsolutePath: ValueGraphDependency] = [:]
+        let graphTraverser = GraphTraverser(graph: graph)
+        var visitedPrecompiledFrameworkPaths: [GraphTarget: VisitedPrecompiledFramework?] = [:]
+        var loadedPrecompiledDependencies: [AbsolutePath: GraphDependency] = [:]
         let userSpecifiedSourceTargets = graphTraverser.allTargets().filter { sources.contains($0.target.name) }
         let userSpecifiedSourceTestTargets = userSpecifiedSourceTargets.flatMap {
             graphTraverser.testTargetsDependingOn(path: $0.path, name: $0.target.name)
         }
-        var sourceTargets: Set<ValueGraphTarget> = Set(userSpecifiedSourceTargets)
+        var sourceTargets: Set<GraphTarget> = Set(userSpecifiedSourceTargets)
 
         /// New graph dependencies
-        var graphDependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [:]
+        var graphDependencies: [GraphDependency: Set<GraphDependency>] = [:]
         try (userSpecifiedSourceTargets + userSpecifiedSourceTestTargets)
             .forEach {
                 try visit(
@@ -91,17 +91,17 @@ class CacheGraphMutator: CacheGraphMutating {
     }
 
     fileprivate func visit(
-        target: ValueGraphTarget,
-        graph: ValueGraph,
-        graphDependencies: inout [ValueGraphDependency: Set<ValueGraphDependency>],
-        precompiledFrameworks: [ValueGraphTarget: AbsolutePath],
+        target: GraphTarget,
+        graph: Graph,
+        graphDependencies: inout [GraphDependency: Set<GraphDependency>],
+        precompiledFrameworks: [GraphTarget: AbsolutePath],
         sources: Set<String>,
-        sourceTargets: inout Set<ValueGraphTarget>,
-        visitedPrecompiledFrameworkPaths: inout [ValueGraphTarget: VisitedPrecompiledFramework?],
-        loadedPrecompiledNodes: inout [AbsolutePath: ValueGraphDependency]
+        sourceTargets: inout Set<GraphTarget>,
+        visitedPrecompiledFrameworkPaths: inout [GraphTarget: VisitedPrecompiledFramework?],
+        loadedPrecompiledNodes: inout [AbsolutePath: GraphDependency]
     ) throws {
         sourceTargets.formUnion([target])
-        let targetDependency: ValueGraphDependency = .target(name: target.target.name, path: target.path)
+        let targetDependency: GraphDependency = .target(name: target.target.name, path: target.path)
         graphDependencies[
             targetDependency
         ] = try mapDependencies(
@@ -118,19 +118,19 @@ class CacheGraphMutator: CacheGraphMutating {
 
     // swiftlint:disable:next function_body_length
     fileprivate func mapDependencies(
-        _ dependencies: Set<ValueGraphDependency>,
-        graph: ValueGraph,
-        graphDependencies: inout [ValueGraphDependency: Set<ValueGraphDependency>],
-        precompiledFrameworks: [ValueGraphTarget: AbsolutePath],
+        _ dependencies: Set<GraphDependency>,
+        graph: Graph,
+        graphDependencies: inout [GraphDependency: Set<GraphDependency>],
+        precompiledFrameworks: [GraphTarget: AbsolutePath],
         sources: Set<String>,
-        sourceTargets: inout Set<ValueGraphTarget>,
-        visitedPrecompiledFrameworkPaths: inout [ValueGraphTarget: VisitedPrecompiledFramework?],
-        loadedPrecompiledFrameworks: inout [AbsolutePath: ValueGraphDependency]
-    ) throws -> Set<ValueGraphDependency> {
-        var newDependencies: Set<ValueGraphDependency> = Set()
+        sourceTargets: inout Set<GraphTarget>,
+        visitedPrecompiledFrameworkPaths: inout [GraphTarget: VisitedPrecompiledFramework?],
+        loadedPrecompiledFrameworks: inout [AbsolutePath: GraphDependency]
+    ) throws -> Set<GraphDependency> {
+        var newDependencies: Set<GraphDependency> = Set()
         try dependencies.forEach { dependency in
-            let graphTraverser = ValueGraphTraverser(graph: graph)
-            let targetDependency: ValueGraphTarget
+            let graphTraverser = GraphTraverser(graph: graph)
+            let targetDependency: GraphTarget
             switch dependency {
             case let .target(name: name, path: path):
                 guard
@@ -173,7 +173,7 @@ class CacheGraphMutator: CacheGraphMutating {
             }
 
             // We load the .framework (or fallback on .xcframework)
-            let precompiledFramework: ValueGraphDependency = try loadPrecompiledFramework(
+            let precompiledFramework: GraphDependency = try loadPrecompiledFramework(
                 path: precompiledFrameworkPath,
                 loadedPrecompiledFrameworks: &loadedPrecompiledFrameworks
             )
@@ -206,25 +206,25 @@ class CacheGraphMutator: CacheGraphMutating {
 
     fileprivate func loadPrecompiledFramework(
         path: AbsolutePath,
-        loadedPrecompiledFrameworks: inout [AbsolutePath: ValueGraphDependency]
-    ) throws -> ValueGraphDependency {
+        loadedPrecompiledFrameworks: inout [AbsolutePath: GraphDependency]
+    ) throws -> GraphDependency {
         if let cachedFramework = loadedPrecompiledFrameworks[path] {
             return cachedFramework
-        } else if let framework: ValueGraphDependency = try? frameworkLoader.load(path: path) {
+        } else if let framework: GraphDependency = try? frameworkLoader.load(path: path) {
             loadedPrecompiledFrameworks[path] = framework
             return framework
         } else {
-            let xcframework: ValueGraphDependency = try xcframeworkLoader.load(path: path)
+            let xcframework: GraphDependency = try xcframeworkLoader.load(path: path)
             loadedPrecompiledFrameworks[path] = xcframework
             return xcframework
         }
     }
 
     fileprivate func precompiledFrameworkPath(
-        target: ValueGraphTarget,
+        target: GraphTarget,
         graphTraverser: GraphTraversing,
-        precompiledFrameworks: [ValueGraphTarget: AbsolutePath],
-        visitedPrecompiledFrameworkPaths: inout [ValueGraphTarget: VisitedPrecompiledFramework?]
+        precompiledFrameworks: [GraphTarget: AbsolutePath],
+        visitedPrecompiledFrameworkPaths: inout [GraphTarget: VisitedPrecompiledFramework?]
     ) -> AbsolutePath? {
         // Already visited
         if let visited = visitedPrecompiledFrameworkPaths[target] { return visited?.path }

Sources/TuistCache/GraphMappers/CacheMapper.swift

@@ -72,7 +72,7 @@ public class CacheMapper: GraphMapping {
 
     // MARK: - GraphMapping
 
-    public func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor]) {
+    public func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor]) {
         let single = hashes(graph: graph).flatMap { self.map(graph: graph, hashes: $0, sources: self.sources) }
         return try (single.toBlocking().single(), [])
     }
@@ -84,7 +84,7 @@ public class CacheMapper: GraphMapping {
         return DispatchQueue(label: "io.tuist.generator-cache-mapper.\(qos)", qos: qos, attributes: [], target: nil)
     }
 
-    private func hashes(graph: ValueGraph) -> Single<[ValueGraphTarget: String]> {
+    private func hashes(graph: Graph) -> Single<[GraphTarget: String]> {
         Single.create { (observer) -> Disposable in
             do {
                 let hashes = try self.cacheGraphContentHasher.contentHashes(
@@ -101,7 +101,7 @@ public class CacheMapper: GraphMapping {
         .subscribeOn(ConcurrentDispatchQueueScheduler(queue: queue))
     }
 
-    private func map(graph: ValueGraph, hashes: [ValueGraphTarget: String], sources: Set<String>) -> Single<ValueGraph> {
+    private func map(graph: Graph, hashes: [GraphTarget: String], sources: Set<String>) -> Single<Graph> {
         fetch(hashes: hashes).map { xcframeworkPaths in
             try self.cacheGraphMutator.map(
                 graph: graph,
@@ -111,16 +111,16 @@ public class CacheMapper: GraphMapping {
         }
     }
 
-    private func fetch(hashes: [ValueGraphTarget: String]) -> Single<[ValueGraphTarget: AbsolutePath]> {
+    private func fetch(hashes: [GraphTarget: String]) -> Single<[GraphTarget: AbsolutePath]> {
         Single.zip(hashes.map { target, hash in
             self.cache.exists(hash: hash)
-                .flatMap { (exists) -> Single<(target: ValueGraphTarget, path: AbsolutePath?)> in
+                .flatMap { (exists) -> Single<(target: GraphTarget, path: AbsolutePath?)> in
                     guard exists else { return Single.just((target: target, path: nil)) }
                     return self.cache.fetch(hash: hash).map { (target: target, path: $0) }
                 }
         })
             .map { result in
-                result.reduce(into: [ValueGraphTarget: AbsolutePath]()) { acc, next in
+                result.reduce(into: [GraphTarget: AbsolutePath]()) { acc, next in
                     guard let path = next.path else { return }
                     acc[next.target] = path
                 }

Sources/TuistCache/GraphMappers/CacheTreeShakingGraphMapper.swift

@@ -6,7 +6,7 @@ import TuistGraph
 public final class CacheTreeShakingGraphMapper: GraphMapping {
     public init() {}
 
-    public func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor]) {
+    public func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor]) {
         let sourceTargets: Set<TargetReference> = Set(graph.targets.flatMap { (projectPath, targets) -> [TargetReference] in
             guard graph.projects[projectPath] != nil else { return [] }
             return targets.compactMap { (_, target) -> TargetReference? in
@@ -64,7 +64,7 @@ public final class CacheTreeShakingGraphMapper: GraphMapping {
         return workspace
     }
 
-    fileprivate func treeShake(targets: [Target], path: AbsolutePath, graph: ValueGraph, sourceTargets: Set<TargetReference>) -> [Target] {
+    fileprivate func treeShake(targets: [Target], path: AbsolutePath, graph: Graph, sourceTargets: Set<TargetReference>) -> [Target] {
         targets.compactMap { (target) -> Target? in
             guard let target = graph.targets[path, default: [:]][target.name] else { return nil }
             let targetReference = TargetReference(projectPath: path, name: target.name)

Sources/TuistCache/GraphMappers/TestsCacheGraphMapper.swift

@@ -40,15 +40,15 @@ public final class TestsCacheGraphMapper: GraphMapping {
         self.cacheDirectoryProviderFactory = cacheDirectoryProviderFactory
     }
 
-    public func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor]) {
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+    public func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor]) {
+        let graphTraverser = GraphTraverser(graph: graph)
         let hashableTargets = self.hashableTargets(graphTraverser: graphTraverser)
         let hashes = try graphContentHasher.contentHashes(for: graph, filter: hashableTargets.contains)
         let testsCacheDirectory = try cacheDirectoryProviderFactory.cacheDirectories(config: config).testsCacheDirectory
-        var visitedNodes: [ValueGraphTarget: Bool] = [:]
+        var visitedNodes: [GraphTarget: Bool] = [:]
         var workspace = graph.workspace
         let mappedSchemes = try workspace.schemes
-            .map { scheme -> (Scheme, [ValueGraphTarget]) in
+            .map { scheme -> (Scheme, [GraphTarget]) in
                 try map(
                     scheme: scheme,
                     graphTraverser: graphTraverser,
@@ -79,15 +79,15 @@ public final class TestsCacheGraphMapper: GraphMapping {
 
     // MARK: - Helpers
 
-    private func hashableTargets(graphTraverser: GraphTraversing) -> Set<ValueGraphTarget> {
-        var visitedTargets: [ValueGraphTarget: Bool] = [:]
+    private func hashableTargets(graphTraverser: GraphTraversing) -> Set<GraphTarget> {
+        var visitedTargets: [GraphTarget: Bool] = [:]
         return Set(
             graphTraverser.allTargets()
                 // UI tests depend on the device they are run on
                 // This can be done in the future if we hash the ID of the device
                 // But currently, we consider for hashing only unit tests and its dependencies
                 .filter { $0.target.product == .unitTests }
-                .flatMap { target -> [ValueGraphTarget] in
+                .flatMap { target -> [GraphTarget] in
                     targetDependencies(
                         target,
                         graphTraverser: graphTraverser,
@@ -98,10 +98,10 @@ public final class TestsCacheGraphMapper: GraphMapping {
     }
 
     private func targetDependencies(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         graphTraverser: GraphTraversing,
-        visited: inout [ValueGraphTarget: Bool]
-    ) -> [ValueGraphTarget] {
+        visited: inout [GraphTarget: Bool]
+    ) -> [GraphTarget] {
         if visited[target] == true { return [] }
         let targetDependencies = graphTraverser.directTargetDependencies(
             path: target.path,
@@ -118,7 +118,7 @@ public final class TestsCacheGraphMapper: GraphMapping {
         return targetDependencies + [target]
     }
 
-    private func testableTargets(scheme: Scheme, graphTraverser: GraphTraversing) -> [ValueGraphTarget] {
+    private func testableTargets(scheme: Scheme, graphTraverser: GraphTraversing) -> [GraphTarget] {
         scheme.testAction
             .map(\.targets)
             .map { testTargets in
@@ -127,7 +127,7 @@ public final class TestsCacheGraphMapper: GraphMapping {
                         let target = graphTraverser.targets[testTarget.target.projectPath]?[testTarget.target.name],
                         let project = graphTraverser.projects[testTarget.target.projectPath]
                     else { return nil }
-                    return ValueGraphTarget(
+                    return GraphTarget(
                         path: testTarget.target.projectPath,
                         target: target,
                         project: project
@@ -140,10 +140,10 @@ public final class TestsCacheGraphMapper: GraphMapping {
     private func map(
         scheme: Scheme,
         graphTraverser: GraphTraversing,
-        hashes: [ValueGraphTarget: String],
-        visited: inout [ValueGraphTarget: Bool],
+        hashes: [GraphTarget: String],
+        visited: inout [GraphTarget: Bool],
         testsCacheDirectory: AbsolutePath
-    ) throws -> (Scheme, [ValueGraphTarget]) {
+    ) throws -> (Scheme, [GraphTarget]) {
         var scheme = scheme
         guard let testAction = scheme.testAction else { return (scheme, []) }
         let cachedTestableTargets = testableTargets(
@@ -174,10 +174,10 @@ public final class TestsCacheGraphMapper: GraphMapping {
     }
 
     private func isCached(
-        _ target: ValueGraphTarget,
+        _ target: GraphTarget,
         graphTraverser: GraphTraversing,
-        hashes: [ValueGraphTarget: String],
-        visited: inout [ValueGraphTarget: Bool],
+        hashes: [GraphTarget: String],
+        visited: inout [GraphTarget: Bool],
         testsCacheDirectory: AbsolutePath
     ) -> Bool {
         if let visitedValue = visited[target] { return visitedValue }

Sources/TuistCache/Linters/CacheGraphLinter.swift

@@ -8,14 +8,14 @@ import TuistSupport
 public protocol CacheGraphLinting {
     /// Lint a given graph.
     /// - Parameter graph: Graph to be linted.
-    func lint(graph: ValueGraph)
+    func lint(graph: Graph)
 }
 
 public final class CacheGraphLinter: CacheGraphLinting {
     public init() {}
 
-    public func lint(graph: ValueGraph) {
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+    public func lint(graph: Graph) {
+        let graphTraverser = GraphTraverser(graph: graph)
         let targets = graphTraverser.allTargets()
         let targetsWithActions = targets.filter { $0.target.actions.count != 0 }
         if !targetsWithActions.isEmpty {

Sources/TuistCacheTesting/ContentHashing/Mocks/MockCacheGraphContentHasher.swift

@@ -6,12 +6,12 @@ import TuistGraph
 public final class MockCacheGraphContentHasher: CacheGraphContentHashing {
     public init() {}
 
-    public var contentHashesStub: ((ValueGraph, TuistGraph.Cache.Profile, CacheOutputType) throws -> [ValueGraphTarget: String])?
+    public var contentHashesStub: ((Graph, TuistGraph.Cache.Profile, CacheOutputType) throws -> [GraphTarget: String])?
     public func contentHashes(
-        for graph: ValueGraph,
+        for graph: Graph,
         cacheProfile: TuistGraph.Cache.Profile,
         cacheOutputType: CacheOutputType
-    ) throws -> [ValueGraphTarget: String] {
+    ) throws -> [GraphTarget: String] {
         try contentHashesStub?(graph, cacheProfile, cacheOutputType) ?? [:]
     }
 }

Sources/TuistCacheTesting/ContentHashing/Mocks/MockGraphContentHasher.swift

@@ -6,12 +6,12 @@ import TuistGraph
 public final class MockGraphContentHasher: GraphContentHashing {
     public init() {}
 
-    public var contentHashesStub: ((ValueGraph, (ValueGraphTarget) -> Bool, [String]) throws -> [ValueGraphTarget: String])?
+    public var contentHashesStub: ((Graph, (GraphTarget) -> Bool, [String]) throws -> [GraphTarget: String])?
     public func contentHashes(
-        for graph: ValueGraph,
-        filter: (ValueGraphTarget) -> Bool,
+        for graph: Graph,
+        filter: (GraphTarget) -> Bool,
         additionalStrings: [String]
-    ) throws -> [ValueGraphTarget: String] {
+    ) throws -> [GraphTarget: String] {
         try contentHashesStub?(graph, filter, additionalStrings) ?? [:]
     }
 }

Sources/TuistCacheTesting/Linters/Mocks/MockCacheGraphLinter.swift

@@ -6,12 +6,12 @@ import TuistGraph
 public final class MockCacheGraphLinter: CacheGraphLinting {
     public var invokedLint = false
     public var invokedLintCount = 0
-    public var invokedLintParameters: (graph: ValueGraph, Void)?
-    public var invokedLintParametersList = [(graph: ValueGraph, Void)]()
+    public var invokedLintParameters: (graph: Graph, Void)?
+    public var invokedLintParametersList = [(graph: Graph, Void)]()
 
     public init() {}
 
-    public func lint(graph: ValueGraph) {
+    public func lint(graph: Graph) {
         invokedLint = true
         invokedLintCount += 1
         invokedLintParameters = (graph, ())

Sources/TuistCore/Graph/GraphDependencyReference.swift

@@ -28,7 +28,7 @@ public enum GraphDependencyReference: Equatable, Comparable, Hashable {
     case product(target: String, productName: String)
     case sdk(path: AbsolutePath, status: SDKStatus, source: SDKSource)
 
-    init(_ dependency: ValueGraphDependency) {
+    init(_ dependency: GraphDependency) {
         switch dependency {
         case let .framework(path, binaryPath, dsymPath, bcsymbolmapPaths, linking, architectures, isCarthage):
             self = .framework(

Sources/TuistCore/Graph/GraphLoader.swift

@@ -2,15 +2,15 @@ import Foundation
 import TSCBasic
 import TuistGraph
 
-public protocol ValueGraphLoading {
-    func loadWorkspace(workspace: Workspace, projects: [Project]) throws -> ValueGraph
-    func loadProject(at path: AbsolutePath, projects: [Project]) throws -> (Project, ValueGraph)
+public protocol GraphLoading {
+    func loadWorkspace(workspace: Workspace, projects: [Project]) throws -> Graph
+    func loadProject(at path: AbsolutePath, projects: [Project]) throws -> (Project, Graph)
 }
 
-// MARK: - ValueGraphLoader
+// MARK: - GraphLoader
 
 // swiftlint:disable:next type_body_length
-public final class ValueGraphLoader: ValueGraphLoading {
+public final class GraphLoader: GraphLoading {
     private let frameworkMetadataProvider: FrameworkMetadataProviding
     private let libraryMetadataProvider: LibraryMetadataProviding
     private let xcframeworkMetadataProvider: XCFrameworkMetadataProviding
@@ -37,9 +37,9 @@ public final class ValueGraphLoader: ValueGraphLoading {
         self.systemFrameworkMetadataProvider = systemFrameworkMetadataProvider
     }
 
-    // MARK: - ValueGraphLoading
+    // MARK: - GraphLoading
 
-    public func loadWorkspace(workspace: Workspace, projects: [Project]) throws -> ValueGraph {
+    public func loadWorkspace(workspace: Workspace, projects: [Project]) throws -> Graph {
         let cache = Cache(projects: projects)
         let cycleDetector = GraphCircularDetector()
 
@@ -52,7 +52,7 @@ public final class ValueGraphLoader: ValueGraphLoading {
         }
 
         let updatedWorkspace = workspace.replacing(projects: cache.loadedProjects.keys.sorted())
-        let graph = ValueGraph(
+        let graph = Graph(
             name: updatedWorkspace.name,
             path: updatedWorkspace.path,
             workspace: updatedWorkspace,
@@ -64,7 +64,7 @@ public final class ValueGraphLoader: ValueGraphLoading {
         return graph
     }
 
-    public func loadProject(at path: AbsolutePath, projects: [Project]) throws -> (Project, ValueGraph) {
+    public func loadProject(at path: AbsolutePath, projects: [Project]) throws -> (Project, Graph) {
         let cache = Cache(projects: projects)
         guard let rootProject = cache.allProjects[path] else {
             throw GraphLoadingError.missingProject(path)
@@ -78,7 +78,7 @@ public final class ValueGraphLoader: ValueGraphLoading {
             name: rootProject.name,
             projects: cache.loadedProjects.keys.sorted()
         )
-        let graph = ValueGraph(
+        let graph = Graph(
             name: rootProject.name,
             path: path,
             workspace: workspace,
@@ -159,7 +159,7 @@ public final class ValueGraphLoader: ValueGraphLoading {
         dependency: TargetDependency,
         cache: Cache,
         cycleDetector: GraphCircularDetector
-    ) throws -> ValueGraphDependency {
+    ) throws -> GraphDependency {
         switch dependency {
         case let .target(toTarget):
             // A target within the same project.
@@ -216,13 +216,13 @@ public final class ValueGraphLoader: ValueGraphLoading {
         }
     }
 
-    private func loadFramework(path: AbsolutePath, cache: Cache) throws -> ValueGraphDependency {
+    private func loadFramework(path: AbsolutePath, cache: Cache) throws -> GraphDependency {
         if let loaded = cache.frameworks[path] {
             return loaded
         }
 
         let metadata = try frameworkMetadataProvider.loadMetadata(at: path)
-        let framework: ValueGraphDependency = .framework(
+        let framework: GraphDependency = .framework(
             path: metadata.path,
             binaryPath: metadata.binaryPath,
             dsymPath: metadata.dsymPath,
@@ -240,7 +240,7 @@ public final class ValueGraphLoader: ValueGraphLoading {
         publicHeaders: AbsolutePath,
         swiftModuleMap: AbsolutePath?,
         cache: Cache
-    ) throws -> ValueGraphDependency {
+    ) throws -> GraphDependency {
         if let loaded = cache.libraries[path] {
             return loaded
         }
@@ -250,7 +250,7 @@ public final class ValueGraphLoader: ValueGraphLoading {
             publicHeaders: publicHeaders,
             swiftModuleMap: swiftModuleMap
         )
-        let library: ValueGraphDependency = .library(
+        let library: GraphDependency = .library(
             path: metadata.path,
             publicHeaders: metadata.publicHeaders,
             linking: metadata.linking,
@@ -261,13 +261,13 @@ public final class ValueGraphLoader: ValueGraphLoading {
         return library
     }
 
-    private func loadXCFramework(path: AbsolutePath, cache: Cache) throws -> ValueGraphDependency {
+    private func loadXCFramework(path: AbsolutePath, cache: Cache) throws -> GraphDependency {
         if let loaded = cache.xcframeworks[path] {
             return loaded
         }
 
         let metadata = try xcframeworkMetadataProvider.loadMetadata(at: path)
-        let xcframework: ValueGraphDependency = .xcframework(
+        let xcframework: GraphDependency = .xcframework(
             path: metadata.path,
             infoPlist: metadata.infoPlist,
             primaryBinaryPath: metadata.primaryBinaryPath,
@@ -280,18 +280,18 @@ public final class ValueGraphLoader: ValueGraphLoading {
     private func loadSDK(name: String,
                          platform: Platform,
                          status: SDKStatus,
-                         source: SDKSource) throws -> ValueGraphDependency
+                         source: SDKSource) throws -> GraphDependency
     {
         let metadata = try systemFrameworkMetadataProvider.loadMetadata(sdkName: name, status: status, platform: platform, source: source)
         return .sdk(name: metadata.name, path: metadata.path, status: metadata.status, source: metadata.source)
     }
 
-    private func loadXCTestSDK(platform: Platform) throws -> ValueGraphDependency {
+    private func loadXCTestSDK(platform: Platform) throws -> GraphDependency {
         let metadata = try systemFrameworkMetadataProvider.loadXCTestMetadata(platform: platform)
         return .sdk(name: metadata.name, path: metadata.path, status: metadata.status, source: metadata.source)
     }
 
-    private func loadPackage(fromPath: AbsolutePath, productName: String) throws -> ValueGraphDependency {
+    private func loadPackage(fromPath: AbsolutePath, productName: String) throws -> GraphDependency {
         // TODO: `fromPath` isn't quite correct as it reflects the path where the dependency was declared
         // and doesn't uniquely identify it. It's been copied from the previous implementation to maintain
         // existing behaviour and should be fixed separately
@@ -307,10 +307,10 @@ public final class ValueGraphLoader: ValueGraphLoading {
 
         var loadedProjects: [AbsolutePath: Project] = [:]
         var loadedTargets: [AbsolutePath: [String: Target]] = [:]
-        var dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [:]
-        var frameworks: [AbsolutePath: ValueGraphDependency] = [:]
-        var libraries: [AbsolutePath: ValueGraphDependency] = [:]
-        var xcframeworks: [AbsolutePath: ValueGraphDependency] = [:]
+        var dependencies: [GraphDependency: Set<GraphDependency>] = [:]
+        var frameworks: [AbsolutePath: GraphDependency] = [:]
+        var libraries: [AbsolutePath: GraphDependency] = [:]
+        var xcframeworks: [AbsolutePath: GraphDependency] = [:]
         var packages: [AbsolutePath: [String: Package]] = [:]
 
         init(projects: [Project]) {
@@ -333,15 +333,15 @@ public final class ValueGraphLoader: ValueGraphLoading {
             loadedTargets[path, default: [:]][target.name] = target
         }
 
-        func add(framework: ValueGraphDependency, at path: AbsolutePath) {
+        func add(framework: GraphDependency, at path: AbsolutePath) {
             frameworks[path] = framework
         }
 
-        func add(xcframework: ValueGraphDependency, at path: AbsolutePath) {
+        func add(xcframework: GraphDependency, at path: AbsolutePath) {
             xcframeworks[path] = xcframework
         }
 
-        func add(library: ValueGraphDependency, at path: AbsolutePath) {
+        func add(library: GraphDependency, at path: AbsolutePath) {
             libraries[path] = library
         }
 

Sources/TuistCore/Graph/GraphTraverser.swift

@@ -4,19 +4,19 @@ import TuistGraph
 import TuistSupport
 
 // swiftlint:disable type_body_length
-public class ValueGraphTraverser: GraphTraversing {
+public class GraphTraverser: GraphTraversing {
     public var name: String { graph.name }
     public var hasPackages: Bool { !graph.packages.flatMap(\.value).isEmpty }
     public var path: AbsolutePath { graph.path }
     public var workspace: Workspace { graph.workspace }
     public var projects: [AbsolutePath: Project] { graph.projects }
     public var targets: [AbsolutePath: [String: Target]] { graph.targets }
-    public var dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] { graph.dependencies }
+    public var dependencies: [GraphDependency: Set<GraphDependency>] { graph.dependencies }
 
-    private let graph: ValueGraph
+    private let graph: Graph
     private let systemFrameworkMetadataProvider: SystemFrameworkMetadataProviding = SystemFrameworkMetadataProvider()
 
-    public required init(graph: ValueGraph) {
+    public required init(graph: Graph) {
         self.graph = graph
     }
 
@@ -29,17 +29,17 @@ public class ValueGraphTraverser: GraphTraversing {
         }) != nil
     }
 
-    public func rootTargets() -> Set<ValueGraphTarget> {
+    public func rootTargets() -> Set<GraphTarget> {
         Set(graph.workspace.projects.reduce(into: Set()) { result, path in
             result.formUnion(targets(at: path))
         })
     }
 
-    public func allTargets() -> Set<ValueGraphTarget> {
-        Set(projects.flatMap { (projectPath, project) -> [ValueGraphTarget] in
+    public func allTargets() -> Set<GraphTarget> {
+        Set(projects.flatMap { (projectPath, project) -> [GraphTarget] in
             let targets = graph.targets[projectPath, default: [:]]
             return targets.values.map { target in
-                ValueGraphTarget(path: projectPath, target: target, project: project)
+                GraphTarget(path: projectPath, target: target, project: project)
             }
         })
     }
@@ -58,11 +58,11 @@ public class ValueGraphTraverser: GraphTraversing {
         dependencies.reduce(into: Set<AbsolutePath>()) { acc, next in
             let fromDependency = next.key
             let toDependencies = next.value
-            if case let ValueGraphDependency.cocoapods(path) = fromDependency {
+            if case let GraphDependency.cocoapods(path) = fromDependency {
                 acc.insert(path)
             }
             toDependencies.forEach { toDependency in
-                if case let ValueGraphDependency.cocoapods(path) = toDependency {
+                if case let GraphDependency.cocoapods(path) = toDependency {
                     acc.insert(path)
                 }
             }
@@ -70,40 +70,40 @@ public class ValueGraphTraverser: GraphTraversing {
     }
 
     public func precompiledFrameworksPaths() -> Set<AbsolutePath> {
-        let dependencies = graph.dependencies.reduce(into: Set<ValueGraphDependency>()) { acc, next in
+        let dependencies = graph.dependencies.reduce(into: Set<GraphDependency>()) { acc, next in
             acc.formUnion([next.key])
             acc.formUnion(next.value)
         }
         return Set(dependencies.compactMap { dependency -> AbsolutePath? in
-            guard case let ValueGraphDependency.framework(path, _, _, _, _, _, _) = dependency else { return nil }
+            guard case let GraphDependency.framework(path, _, _, _, _, _, _) = dependency else { return nil }
             return path
         })
     }
 
-    public func targets(product: Product) -> Set<ValueGraphTarget> {
-        var filteredTargets: Set<ValueGraphTarget> = Set()
+    public func targets(product: Product) -> Set<GraphTarget> {
+        var filteredTargets: Set<GraphTarget> = Set()
         targets.forEach { path, projectTargets in
             projectTargets.values.forEach { target in
                 guard target.product == product else { return }
                 guard let project = projects[path] else { return }
-                filteredTargets.formUnion([ValueGraphTarget(path: path, target: target, project: project)])
+                filteredTargets.formUnion([GraphTarget(path: path, target: target, project: project)])
             }
         }
         return filteredTargets
     }
 
-    public func target(path: AbsolutePath, name: String) -> ValueGraphTarget? {
+    public func target(path: AbsolutePath, name: String) -> GraphTarget? {
         guard let project = graph.projects[path], let target = graph.targets[path]?[name] else { return nil }
-        return ValueGraphTarget(path: path, target: target, project: project)
+        return GraphTarget(path: path, target: target, project: project)
     }
 
-    public func targets(at path: AbsolutePath) -> Set<ValueGraphTarget> {
+    public func targets(at path: AbsolutePath) -> Set<GraphTarget> {
         guard let project = graph.projects[path] else { return Set() }
         guard let targets = graph.targets[path] else { return [] }
-        return Set(targets.values.map { ValueGraphTarget(path: path, target: $0, project: project) })
+        return Set(targets.values.map { GraphTarget(path: path, target: $0, project: project) })
     }
 
-    public func directTargetDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    public func directTargetDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         guard
             let dependencies = graph.dependencies[.target(name: name, path: path)]
         else { return [] }
@@ -111,7 +111,7 @@ public class ValueGraphTraverser: GraphTraversing {
         let targetDependencies = dependencies
             .compactMap(\.targetDependency)
 
-        return Set(targetDependencies.flatMap { (dependencyName, dependencyPath) -> [ValueGraphTarget] in
+        return Set(targetDependencies.flatMap { (dependencyName, dependencyPath) -> [GraphTarget] in
             guard
                 let projectDependencies = graph.targets[dependencyPath],
                 let dependencyTarget = projectDependencies[dependencyName],
@@ -119,36 +119,36 @@ public class ValueGraphTraverser: GraphTraversing {
             else {
                 return []
             }
-            return [ValueGraphTarget(path: dependencyPath, target: dependencyTarget, project: dependencyProject)]
+            return [GraphTarget(path: dependencyPath, target: dependencyTarget, project: dependencyProject)]
         })
     }
 
-    public func directLocalTargetDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    public func directLocalTargetDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         guard let dependencies = graph.dependencies[.target(name: name, path: path)] else { return [] }
         guard let project = graph.projects[path] else { return Set() }
 
         let localTargetDependencies = dependencies
             .compactMap(\.targetDependency)
             .filter { $0.path == path }
-        return Set(localTargetDependencies.flatMap { (dependencyName, dependencyPath) -> [ValueGraphTarget] in
+        return Set(localTargetDependencies.flatMap { (dependencyName, dependencyPath) -> [GraphTarget] in
             guard let projectDependencies = graph.targets[dependencyPath],
                 let dependencyTarget = projectDependencies[dependencyName]
             else {
                 return []
             }
-            return [ValueGraphTarget(path: path, target: dependencyTarget, project: project)]
+            return [GraphTarget(path: path, target: dependencyTarget, project: project)]
         })
     }
 
-    public func resourceBundleDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    public func resourceBundleDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         guard let target = graph.targets[path]?[name] else { return [] }
         guard target.supportsResources else { return [] }
 
-        let canHostResources: (ValueGraphDependency) -> Bool = {
+        let canHostResources: (GraphDependency) -> Bool = {
             self.target(from: $0)?.target.supportsResources == true
         }
 
-        let isBundle: (ValueGraphDependency) -> Bool = {
+        let isBundle: (GraphDependency) -> Bool = {
             self.target(from: $0)?.target.product == .bundle
         }
 
@@ -162,25 +162,25 @@ public class ValueGraphTraverser: GraphTraversing {
         return Set(bundleTargets)
     }
 
-    public func testTargetsDependingOn(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    public func testTargetsDependingOn(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         guard let project = graph.projects[path] else { return Set() }
 
         return Set(graph.targets[path]?.values
             .filter { $0.product.testsBundle }
             .filter { graph.dependencies[.target(name: $0.name, path: path)]?.contains(.target(name: name, path: path)) == true }
-            .map { ValueGraphTarget(path: path, target: $0, project: project) } ?? [])
+            .map { GraphTarget(path: path, target: $0, project: project) } ?? [])
     }
 
-    public func target(from dependency: ValueGraphDependency) -> ValueGraphTarget? {
-        guard case let ValueGraphDependency.target(name, path) = dependency else {
+    public func target(from dependency: GraphDependency) -> GraphTarget? {
+        guard case let GraphDependency.target(name, path) = dependency else {
             return nil
         }
         guard let target = graph.targets[path]?[name] else { return nil }
         guard let project = graph.projects[path] else { return nil }
-        return ValueGraphTarget(path: path, target: target, project: project)
+        return GraphTarget(path: path, target: target, project: project)
     }
 
-    public func appExtensionDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    public func appExtensionDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         let validProducts: [Product] = [
             .appExtension, .stickerPackExtension, .watch2Extension, .tvTopShelfExtension, .messagesExtension,
         ]
@@ -188,15 +188,15 @@ public class ValueGraphTraverser: GraphTraversing {
             .filter { validProducts.contains($0.target.product) })
     }
 
-    public func appClipDependencies(path: AbsolutePath, name: String) -> ValueGraphTarget? {
+    public func appClipDependencies(path: AbsolutePath, name: String) -> GraphTarget? {
         directLocalTargetDependencies(path: path, name: name)
             .first { $0.target.product == .appClip }
     }
 
     public func directStaticDependencies(path: AbsolutePath, name: String) -> Set<GraphDependencyReference> {
         Set(graph.dependencies[.target(name: name, path: path)]?
-            .compactMap { (dependency: ValueGraphDependency) -> (path: AbsolutePath, name: String)? in
-                guard case let ValueGraphDependency.target(name, path) = dependency else {
+            .compactMap { (dependency: GraphDependency) -> (path: AbsolutePath, name: String)? in
+                guard case let GraphDependency.target(name, path) = dependency else {
                     return nil
                 }
                 return (path, name)
@@ -255,7 +255,7 @@ public class ValueGraphTraverser: GraphTraversing {
                 .flatMap { (dependency) -> [GraphDependencyReference] in
                     let dependencies = self.graph.dependencies[dependency, default: []]
                     return dependencies.compactMap { dependencyDependency -> GraphDependencyReference? in
-                        guard case let ValueGraphDependency.sdk(_, path, status, source) = dependencyDependency else { return nil }
+                        guard case let GraphDependency.sdk(_, path, status, source) = dependencyDependency else { return nil }
                         return .sdk(path: path, status: status, source: source)
                     }
                 }
@@ -281,7 +281,7 @@ public class ValueGraphTraverser: GraphTraversing {
         // Direct system libraries and frameworks
         let directSystemLibrariesAndFrameworks = graph.dependencies[.target(name: name, path: path), default: []]
             .compactMap { dependency -> GraphDependencyReference? in
-                guard case let ValueGraphDependency.sdk(_, path, status, source) = dependency else { return nil }
+                guard case let GraphDependency.sdk(_, path, status, source) = dependency else { return nil }
                 return .sdk(path: path, status: status, source: source)
             }
         references.formUnion(directSystemLibrariesAndFrameworks)
@@ -365,7 +365,7 @@ public class ValueGraphTraverser: GraphTraversing {
     public func librariesPublicHeadersFolders(path: AbsolutePath, name: String) -> Set<AbsolutePath> {
         let dependencies = graph.dependencies[.target(name: name, path: path), default: []]
         let libraryPublicHeaders = dependencies.compactMap { dependency -> AbsolutePath? in
-            guard case let ValueGraphDependency.library(_, publicHeaders, _, _, _) = dependency else { return nil }
+            guard case let GraphDependency.library(_, publicHeaders, _, _, _) = dependency else { return nil }
             return publicHeaders
         }
         return Set(libraryPublicHeaders)
@@ -374,7 +374,7 @@ public class ValueGraphTraverser: GraphTraversing {
     public func librariesSearchPaths(path: AbsolutePath, name: String) -> Set<AbsolutePath> {
         let dependencies = graph.dependencies[.target(name: name, path: path), default: []]
         let libraryPaths = dependencies.compactMap { dependency -> AbsolutePath? in
-            guard case let ValueGraphDependency.library(path, _, _, _, _) = dependency else { return nil }
+            guard case let GraphDependency.library(path, _, _, _, _) = dependency else { return nil }
             return path
         }
         return Set(libraryPaths.compactMap { $0.removingLastComponent() })
@@ -383,7 +383,7 @@ public class ValueGraphTraverser: GraphTraversing {
     public func librariesSwiftIncludePaths(path: AbsolutePath, name: String) -> Set<AbsolutePath> {
         let dependencies = graph.dependencies[.target(name: name, path: path), default: []]
         let librarySwiftModuleMapPaths = dependencies.compactMap { dependency -> AbsolutePath? in
-            guard case let ValueGraphDependency.library(_, _, _, _, swiftModuleMapPath) = dependency else { return nil }
+            guard case let GraphDependency.library(_, _, _, _, swiftModuleMapPath) = dependency else { return nil }
             return swiftModuleMapPath
         }
         return Set(librarySwiftModuleMapPaths.compactMap { $0.removingLastComponent() })
@@ -400,14 +400,14 @@ public class ValueGraphTraverser: GraphTraversing {
 
         var references: Set<AbsolutePath> = Set([])
 
-        let from = ValueGraphDependency.target(name: name, path: path)
+        let from = GraphDependency.target(name: name, path: path)
         let precompiledFramewoksPaths = filterDependencies(
             from: from,
             test: isDependencyPrecompiledDynamicAndLinkable,
             skip: canDependencyEmbedProducts
         )
         .lazy
-        .compactMap { (dependency: ValueGraphDependency) -> AbsolutePath? in
+        .compactMap { (dependency: GraphDependency) -> AbsolutePath? in
             switch dependency {
             case let .xcframework(path, _, _, _): return path
             case let .framework(path, _, _, _, _, _, _): return path
@@ -424,19 +424,19 @@ public class ValueGraphTraverser: GraphTraversing {
         return references
     }
 
-    public func hostTargetFor(path: AbsolutePath, name: String) -> ValueGraphTarget? {
+    public func hostTargetFor(path: AbsolutePath, name: String) -> GraphTarget? {
         guard let targets = graph.targets[path] else { return nil }
         guard let project = graph.projects[path] else { return nil }
 
-        return targets.values.compactMap { (target) -> ValueGraphTarget? in
+        return targets.values.compactMap { (target) -> GraphTarget? in
             let dependencies = self.graph.dependencies[.target(name: target.name, path: path), default: Set()]
             let dependsOnTarget = dependencies.contains(where: { dependency in
                 // swiftlint:disable:next identifier_name
-                guard case let ValueGraphDependency.target(_name, _path) = dependency else { return false }
+                guard case let GraphDependency.target(_name, _path) = dependency else { return false }
                 return _name == name && _path == path
             })
-            let valueGraphTarget = ValueGraphTarget(path: path, target: target, project: project)
-            return dependsOnTarget ? valueGraphTarget : nil
+            let graphTarget = GraphTarget(path: path, target: target, project: project)
+            return dependsOnTarget ? graphTarget : nil
         }.first
     }
 
@@ -482,16 +482,16 @@ public class ValueGraphTraverser: GraphTraversing {
     ///   - from: Dependency from which the traverse is done.
     ///   - test: If the closure returns true, the dependency is included.
     ///   - skip: If the closure returns false, the traversing logic doesn't traverse the dependencies from that dependency.
-    func filterDependencies(from rootDependency: ValueGraphDependency,
-                            test: (ValueGraphDependency) -> Bool = { _ in true },
-                            skip: (ValueGraphDependency) -> Bool = { _ in false }) -> Set<ValueGraphDependency>
+    func filterDependencies(from rootDependency: GraphDependency,
+                            test: (GraphDependency) -> Bool = { _ in true },
+                            skip: (GraphDependency) -> Bool = { _ in false }) -> Set<GraphDependency>
     {
-        var stack = Stack<ValueGraphDependency>()
+        var stack = Stack<GraphDependency>()
 
         stack.push(rootDependency)
 
-        var visited: Set<ValueGraphDependency> = .init()
-        var references = Set<ValueGraphDependency>()
+        var visited: Set<GraphDependency> = .init()
+        var references = Set<GraphDependency>()
 
         while !stack.isEmpty {
             guard let node = stack.pop() else {
@@ -522,7 +522,7 @@ public class ValueGraphTraverser: GraphTraversing {
         return references
     }
 
-    func transitiveStaticTargets(from dependency: ValueGraphDependency) -> Set<ValueGraphDependency> {
+    func transitiveStaticTargets(from dependency: GraphDependency) -> Set<GraphDependency> {
         filterDependencies(
             from: dependency,
             test: isDependencyStaticTarget,
@@ -530,11 +530,11 @@ public class ValueGraphTraverser: GraphTraversing {
         )
     }
 
-    func targetProductReference(target: ValueGraphTarget) -> GraphDependencyReference {
+    func targetProductReference(target: GraphTarget) -> GraphDependencyReference {
         .product(target: target.target.name, productName: target.target.productNameWithExtension)
     }
 
-    func isDependencyPrecompiledLibrary(dependency: ValueGraphDependency) -> Bool {
+    func isDependencyPrecompiledLibrary(dependency: GraphDependency) -> Bool {
         switch dependency {
         case .xcframework: return true
         case .framework: return true
@@ -546,7 +546,7 @@ public class ValueGraphTraverser: GraphTraversing {
         }
     }
 
-    func isDependencyPrecompiledFramework(dependency: ValueGraphDependency) -> Bool {
+    func isDependencyPrecompiledFramework(dependency: GraphDependency) -> Bool {
         switch dependency {
         case .xcframework: return true
         case .framework: return true
@@ -558,25 +558,25 @@ public class ValueGraphTraverser: GraphTraversing {
         }
     }
 
-    func isDependencyStaticTarget(dependency: ValueGraphDependency) -> Bool {
-        guard case let ValueGraphDependency.target(name, path) = dependency,
+    func isDependencyStaticTarget(dependency: GraphDependency) -> Bool {
+        guard case let GraphDependency.target(name, path) = dependency,
             let target = self.target(path: path, name: name) else { return false }
         return target.target.product.isStatic
     }
 
-    func isDependencyDynamicLibrary(dependency: ValueGraphDependency) -> Bool {
-        guard case let ValueGraphDependency.target(name, path) = dependency,
+    func isDependencyDynamicLibrary(dependency: GraphDependency) -> Bool {
+        guard case let GraphDependency.target(name, path) = dependency,
             let target = self.target(path: path, name: name) else { return false }
         return target.target.product == .dynamicLibrary
     }
 
-    func isDependencyFramework(dependency: ValueGraphDependency) -> Bool {
-        guard case let ValueGraphDependency.target(name, path) = dependency,
+    func isDependencyFramework(dependency: GraphDependency) -> Bool {
+        guard case let GraphDependency.target(name, path) = dependency,
             let target = self.target(path: path, name: name) else { return false }
         return target.target.product == .framework
     }
 
-    func isDependencyDynamicTarget(dependency: ValueGraphDependency) -> Bool {
+    func isDependencyDynamicTarget(dependency: GraphDependency) -> Bool {
         switch dependency {
         case .xcframework: return false
         case .framework: return false
@@ -590,7 +590,7 @@ public class ValueGraphTraverser: GraphTraversing {
         }
     }
 
-    func isDependencyPrecompiledDynamicAndLinkable(dependency: ValueGraphDependency) -> Bool {
+    func isDependencyPrecompiledDynamicAndLinkable(dependency: GraphDependency) -> Bool {
         switch dependency {
         case let .xcframework(_, _, _, linking): return linking == .dynamic
         case let .framework(_, _, _, _, linking, _, _): return linking == .dynamic
@@ -602,19 +602,19 @@ public class ValueGraphTraverser: GraphTraversing {
         }
     }
 
-    func canDependencyEmbedProducts(dependency: ValueGraphDependency) -> Bool {
-        guard case let ValueGraphDependency.target(name, path) = dependency,
+    func canDependencyEmbedProducts(dependency: GraphDependency) -> Bool {
+        guard case let GraphDependency.target(name, path) = dependency,
             let target = self.target(path: path, name: name) else { return false }
         return canEmbedProducts(target: target.target)
     }
 
-    func canDependencyLinkStaticProducts(dependency: ValueGraphDependency) -> Bool {
-        guard case let ValueGraphDependency.target(name, path) = dependency,
+    func canDependencyLinkStaticProducts(dependency: GraphDependency) -> Bool {
+        guard case let GraphDependency.target(name, path) = dependency,
             let target = self.target(path: path, name: name) else { return false }
         return target.target.canLinkStaticProducts()
     }
 
-    func hostApplication(path: AbsolutePath, name: String) -> ValueGraphTarget? {
+    func hostApplication(path: AbsolutePath, name: String) -> GraphTarget? {
         directLocalTargetDependencies(path: path, name: name)
             .first(where: { $0.target.product == .app })
     }
@@ -629,7 +629,7 @@ public class ValueGraphTraverser: GraphTraversing {
         return validProducts.contains(target.product)
     }
 
-    func dependencyReference(dependency: ValueGraphDependency) -> GraphDependencyReference? {
+    func dependencyReference(dependency: GraphDependency) -> GraphDependencyReference? {
         switch dependency {
         case .cocoapods:
             return nil

Sources/TuistCore/Graph/Mappers/GraphMapper.swift

@@ -6,21 +6,21 @@ import TuistGraph
 public protocol GraphMapping {
     /// Given a value graph, it maps it into another value graph.
     /// - Parameter graph: Graph to be mapped.
-    func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor])
+    func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor])
 }
 
 /// A mapper that is initialized with a mapping function.
 public final class AnyGraphMapper: GraphMapping {
     /// A function to map the graph.
-    let mapper: (ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor])
+    let mapper: (Graph) throws -> (Graph, [SideEffectDescriptor])
 
     /// Default initializer
     /// - Parameter mapper: Function to map the graph.
-    public init(mapper: @escaping (ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor])) {
+    public init(mapper: @escaping (Graph) throws -> (Graph, [SideEffectDescriptor])) {
         self.mapper = mapper
     }
 
-    public func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor]) {
+    public func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor]) {
         try mapper(graph)
     }
 }
@@ -35,7 +35,7 @@ public final class SequentialGraphMapper: GraphMapping {
         self.mappers = mappers
     }
 
-    public func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor]) {
+    public func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor]) {
         try mappers.reduce((graph, [SideEffectDescriptor]())) { input, mapper in
             let graph = input.0
             var sideEffects = input.1

Sources/TuistCore/Graph/ModelExtensions/Project+Core.swift

@@ -7,7 +7,7 @@ extension Project {
     ///
     /// - Parameter graph: Dependencies graph.
     /// - Returns: Sorted targets.
-    public func sortedTargetsForProjectScheme(graph: ValueGraph) -> [Target] {
+    public func sortedTargetsForProjectScheme(graph: Graph) -> [Target] {
         targets.sorted { (first, second) -> Bool in
             // First criteria: Test bundles at the end
             if first.product.testsBundle, !second.product.testsBundle {
@@ -17,7 +17,7 @@ extension Project {
                 return true
             }
 
-            let graphTraverser = ValueGraphTraverser(graph: graph)
+            let graphTraverser = GraphTraverser(graph: graph)
 
             // Second criteria: Most dependent targets first.
             let secondDependencies = graphTraverser.directTargetDependencies(path: self.path, name: second.name)

Sources/TuistCore/GraphTraverser/GraphTraversing.swift

@@ -25,19 +25,19 @@ public protocol GraphTraversing {
     var targets: [AbsolutePath: [String: Target]] { get }
 
     /// Dependencies.
-    var dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] { get }
+    var dependencies: [GraphDependency: Set<GraphDependency>] { get }
 
     /// Returns all the apps from the graph.
-    func apps() -> Set<ValueGraphTarget>
+    func apps() -> Set<GraphTarget>
 
     /// - Returns: All the schemes of the graph
     func schemes() -> [Scheme]
 
     /// Returns the targets from the project that lives in the directory from which the graph has been loaded.
-    func rootTargets() -> Set<ValueGraphTarget>
+    func rootTargets() -> Set<GraphTarget>
 
     /// Returns all the targets of the project.
-    func allTargets() -> Set<ValueGraphTarget>
+    func allTargets() -> Set<GraphTarget>
 
     /// Returns the paths to directories containing a Podfile
     func cocoapodsPaths() -> Set<AbsolutePath>
@@ -50,49 +50,49 @@ public protocol GraphTraversing {
 
     /// Returns all the targets of a given product.
     /// - Parameter product: Product.
-    func targets(product: Product) -> Set<ValueGraphTarget>
+    func targets(product: Product) -> Set<GraphTarget>
 
     /// It returns the target with the given name in the project that is defined in the given directory path.
     /// - Parameters:
     ///   - path: Path to the directory that contains the definition of the project with the target is defined.
     ///   - name: Name of the target.
-    func target(path: AbsolutePath, name: String) -> ValueGraphTarget?
+    func target(path: AbsolutePath, name: String) -> GraphTarget?
 
     /// It returns the targets of the project defined in the directory at the given path.
     /// - Parameter path: Path to the directory that contains the definition of the project.
-    func targets(at path: AbsolutePath) -> Set<ValueGraphTarget>
+    func targets(at path: AbsolutePath) -> Set<GraphTarget>
 
     /// Given a project directory and target name, it returns **all**l its direct target dependencies present in the same project.
     /// If you want only direct target dependencies present in the same project as the target, use `directLocalTargetDependencies` instead
     /// - Parameters:
     ///   - path: Path to the directory that contains the target's project.
     ///   - name: Target name.
-    func directTargetDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget>
+    func directTargetDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget>
 
     /// Given a project directory and target name, it returns all its direct target dependencies present in the same project.
     /// To get **all** direct target dependencies use the method `directTargetDependencies` instead
     /// - Parameters:
     ///   - path: Path to the directory that contains the project.
     ///   - name: Target name.
-    func directLocalTargetDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget>
+    func directLocalTargetDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget>
 
     /// Given a project directory and a target name, it returns all the dependencies that are extensions.
     /// - Parameters:
     ///   - path: Path to the directory that contains the project.
     ///   - name: Target name.
-    func appExtensionDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget>
+    func appExtensionDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget>
 
     /// Returns the transitive resource bundle dependencies for the given target.
     /// - Parameters:
     ///   - path: Path to the directory where the project that defines the target is located.
     ///   - name: Name of the target.
-    func resourceBundleDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget>
+    func resourceBundleDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget>
 
     /// Returns the list of test targets that depend on the one with the given name at the given path.
     /// - Parameters:
     ///   - path: Path to the directory that contains the project definition.
     ///   - name: Name of the target whose dependant test targets will be returned.
-    func testTargetsDependingOn(path: AbsolutePath, name: String) -> Set<ValueGraphTarget>
+    func testTargetsDependingOn(path: AbsolutePath, name: String) -> Set<GraphTarget>
 
     /// Returns all non-transitive target static dependencies for the given target.
     /// - Parameters:
@@ -104,7 +104,7 @@ public protocol GraphTraversing {
     /// - Parameters:
     ///   - path: Path to the directory that contains the project.
     ///   - name: Target name.
-    func appClipDependencies(path: AbsolutePath, name: String) -> ValueGraphTarget?
+    func appClipDependencies(path: AbsolutePath, name: String) -> GraphTarget?
 
     /// Given a project directory and a target name, it returns the list of dependencies that need to be embedded into the target product.
     /// - Parameters:
@@ -154,7 +154,7 @@ public protocol GraphTraversing {
     /// - Parameters:
     ///     - path; Path to the directory where the project that defines the target
     ///     - name: Name of the target
-    func hostTargetFor(path: AbsolutePath, name: String) -> ValueGraphTarget?
+    func hostTargetFor(path: AbsolutePath, name: String) -> GraphTarget?
 
     /// For the project at the given path, it returns all the dependencies that should
     /// be referenced from the project. This method is intended to be used when generating
@@ -170,7 +170,7 @@ public protocol GraphTraversing {
 }
 
 public extension GraphTraversing {
-    func apps() -> Set<ValueGraphTarget> {
+    func apps() -> Set<GraphTarget> {
         targets(product: .app)
     }
 }

Sources/TuistCore/NodeLoaders/FrameworkLoader.swift

@@ -24,9 +24,9 @@ enum FrameworkLoaderError: FatalError, Equatable {
 }
 
 public protocol FrameworkLoading {
-    /// Reads an existing framework and returns its in-memory representation, `ValueGraphDependency.framework`.
+    /// Reads an existing framework and returns its in-memory representation, `GraphDependency.framework`.
     /// - Parameter path: Path to the .framework.
-    func load(path: AbsolutePath) throws -> ValueGraphDependency
+    func load(path: AbsolutePath) throws -> GraphDependency
 }
 
 public final class FrameworkLoader: FrameworkLoading {
@@ -39,7 +39,7 @@ public final class FrameworkLoader: FrameworkLoading {
         self.frameworkMetadataProvider = frameworkMetadataProvider
     }
 
-    public func load(path: AbsolutePath) throws -> ValueGraphDependency {
+    public func load(path: AbsolutePath) throws -> GraphDependency {
         guard FileHandler.shared.exists(path) else {
             throw FrameworkLoaderError.frameworkNotFound(path)
         }

Sources/TuistCore/NodeLoaders/XCFrameworkLoader.swift

@@ -24,9 +24,9 @@ enum XCFrameworkLoaderError: FatalError, Equatable {
 }
 
 public protocol XCFrameworkLoading {
-    /// Reads an existing xcframework and returns its in-memory representation, `ValueGraphDependency.xcframework`.
+    /// Reads an existing xcframework and returns its in-memory representation, `GraphDependency.xcframework`.
     /// - Parameter path: Path to the .xcframework.
-    func load(path: AbsolutePath) throws -> ValueGraphDependency
+    func load(path: AbsolutePath) throws -> GraphDependency
 }
 
 public final class XCFrameworkLoader: XCFrameworkLoading {
@@ -43,7 +43,7 @@ public final class XCFrameworkLoader: XCFrameworkLoading {
         self.xcframeworkMetadataProvider = xcframeworkMetadataProvider
     }
 
-    public func load(path: AbsolutePath) throws -> ValueGraphDependency {
+    public func load(path: AbsolutePath) throws -> GraphDependency {
         guard FileHandler.shared.exists(path) else {
             throw XCFrameworkLoaderError.xcframeworkNotFound(path)
         }

Sources/TuistCoreTesting/Graph/MockGraphLoader.swift

@@ -4,16 +4,16 @@ import TuistCore
 import TuistGraph
 @testable import TuistGraphTesting
 
-public final class MockValueGraphLoader: ValueGraphLoading {
+public final class MockGraphLoader: GraphLoading {
     public init() {}
 
-    public var loadProjectStub: ((AbsolutePath, [Project]) throws -> (Project, ValueGraph))?
-    public func loadProject(at path: AbsolutePath, projects: [Project]) throws -> (Project, ValueGraph) {
-        return try loadProjectStub?(path, projects) ?? (Project.test(), ValueGraph.test())
+    public var loadProjectStub: ((AbsolutePath, [Project]) throws -> (Project, Graph))?
+    public func loadProject(at path: AbsolutePath, projects: [Project]) throws -> (Project, Graph) {
+        return try loadProjectStub?(path, projects) ?? (Project.test(), Graph.test())
     }
 
-    public var loadWorkspaceStub: ((Workspace, [Project]) throws -> (ValueGraph))?
-    public func loadWorkspace(workspace: Workspace, projects: [Project]) throws -> ValueGraph {
-        return try loadWorkspaceStub?(workspace, projects) ?? ValueGraph.test()
+    public var loadWorkspaceStub: ((Workspace, [Project]) throws -> (Graph))?
+    public func loadWorkspace(workspace: Workspace, projects: [Project]) throws -> Graph {
+        return try loadWorkspaceStub?(workspace, projects) ?? Graph.test()
     }
 }

Sources/TuistCoreTesting/GraphTraverser/MockGraphTraverser.swift

@@ -77,9 +77,9 @@ final class MockGraphTraverser: GraphTraversing {
 
     var invokedDependenciesGetter = false
     var invokedDependenciesGetterCount = 0
-    var stubbedDependencies: [ValueGraphDependency: Set<ValueGraphDependency>]! = [:]
+    var stubbedDependencies: [GraphDependency: Set<GraphDependency>]! = [:]
 
-    var dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] {
+    var dependencies: [GraphDependency: Set<GraphDependency>] {
         invokedDependenciesGetter = true
         invokedDependenciesGetterCount += 1
         return stubbedDependencies
@@ -87,9 +87,9 @@ final class MockGraphTraverser: GraphTraversing {
 
     var invokedApps = false
     var invokedAppsCount = 0
-    var stubbedAppsResult: Set<ValueGraphTarget>! = []
+    var stubbedAppsResult: Set<GraphTarget>! = []
 
-    func apps() -> Set<ValueGraphTarget> {
+    func apps() -> Set<GraphTarget> {
         invokedApps = true
         invokedAppsCount += 1
         return stubbedAppsResult
@@ -97,9 +97,9 @@ final class MockGraphTraverser: GraphTraversing {
 
     var invokedRootTargets = false
     var invokedRootTargetsCount = 0
-    var stubbedRootTargetsResult: Set<ValueGraphTarget>! = []
+    var stubbedRootTargetsResult: Set<GraphTarget>! = []
 
-    func rootTargets() -> Set<ValueGraphTarget> {
+    func rootTargets() -> Set<GraphTarget> {
         invokedRootTargets = true
         invokedRootTargetsCount += 1
         return stubbedRootTargetsResult
@@ -127,9 +127,9 @@ final class MockGraphTraverser: GraphTraversing {
 
     var invokedAllTargets = false
     var invokedAllTargetsCount = 0
-    var stubbedAllTargetsResult: Set<ValueGraphTarget>! = []
+    var stubbedAllTargetsResult: Set<GraphTarget>! = []
 
-    func allTargets() -> Set<ValueGraphTarget> {
+    func allTargets() -> Set<GraphTarget> {
         invokedAllTargets = true
         invokedAllTargetsCount += 1
         return stubbedAllTargetsResult
@@ -149,9 +149,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedTargetsProductCount = 0
     var invokedTargetsProductParameters: (product: Product, Void)?
     var invokedTargetsProductParametersList = [(product: Product, Void)]()
-    var stubbedTargetsProductResult: Set<ValueGraphTarget>! = []
+    var stubbedTargetsProductResult: Set<GraphTarget>! = []
 
-    func targets(product: Product) -> Set<ValueGraphTarget> {
+    func targets(product: Product) -> Set<GraphTarget> {
         invokedTargetsProduct = true
         invokedTargetsProductCount += 1
         invokedTargetsProductParameters = (product, ())
@@ -163,9 +163,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedTargetCount = 0
     var invokedTargetParameters: (path: AbsolutePath, name: String)?
     var invokedTargetParametersList = [(path: AbsolutePath, name: String)]()
-    var stubbedTargetResult: ValueGraphTarget!
+    var stubbedTargetResult: GraphTarget!
 
-    func target(path: AbsolutePath, name: String) -> ValueGraphTarget? {
+    func target(path: AbsolutePath, name: String) -> GraphTarget? {
         invokedTarget = true
         invokedTargetCount += 1
         invokedTargetParameters = (path, name)
@@ -177,9 +177,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedTargetsAtCount = 0
     var invokedTargetsAtParameters: (path: AbsolutePath, Void)?
     var invokedTargetsAtParametersList = [(path: AbsolutePath, Void)]()
-    var stubbedTargetsAtResult: Set<ValueGraphTarget>! = []
+    var stubbedTargetsAtResult: Set<GraphTarget>! = []
 
-    func targets(at path: AbsolutePath) -> Set<ValueGraphTarget> {
+    func targets(at path: AbsolutePath) -> Set<GraphTarget> {
         invokedTargetsAt = true
         invokedTargetsAtCount += 1
         invokedTargetsAtParameters = (path, ())
@@ -192,9 +192,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedDirectLocalTargetDependenciesCount = 0 // swiftlint:disable:this identifier_name
     var invokedDirectLocalTargetDependenciesParameters: (path: AbsolutePath, name: String)? // swiftlint:disable:this identifier_name
     var invokedDirectLocalTargetDependenciesParametersList = [(path: AbsolutePath, name: String)]() // swiftlint:disable:this identifier_name
-    var stubbedDirectLocalTargetDependenciesResult: Set<ValueGraphTarget>! = [] // swiftlint:disable:this identifier_name
+    var stubbedDirectLocalTargetDependenciesResult: Set<GraphTarget>! = [] // swiftlint:disable:this identifier_name
 
-    func directLocalTargetDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    func directLocalTargetDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         invokedDirectLocalTargetDependencies = true
         invokedDirectLocalTargetDependenciesCount += 1
         invokedDirectLocalTargetDependenciesParameters = (path, name)
@@ -206,9 +206,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedDirectTargetDependenciesCount = 0
     var invokedDirectTargetDependenciesParameters: (path: AbsolutePath, name: String)? // swiftlint:disable:this identifier_name
     var invokedDirectTargetDependenciesParametersList = [(path: AbsolutePath, name: String)]() // swiftlint:disable:this identifier_name
-    var stubbedDirectTargetDependenciesResult: Set<ValueGraphTarget>! = []
+    var stubbedDirectTargetDependenciesResult: Set<GraphTarget>! = []
 
-    func directTargetDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    func directTargetDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         invokedDirectTargetDependencies = true
         invokedDirectTargetDependenciesCount += 1
         invokedDirectTargetDependenciesParameters = (path, name)
@@ -220,9 +220,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedAppExtensionDependenciesCount = 0
     var invokedAppExtensionDependenciesParameters: (path: AbsolutePath, name: String)? // swiftlint:disable:this identifier_name
     var invokedAppExtensionDependenciesParametersList = [(path: AbsolutePath, name: String)]() // swiftlint:disable:this identifier_name
-    var stubbedAppExtensionDependenciesResult: Set<ValueGraphTarget>! = []
+    var stubbedAppExtensionDependenciesResult: Set<GraphTarget>! = []
 
-    func appExtensionDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    func appExtensionDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         invokedAppExtensionDependencies = true
         invokedAppExtensionDependenciesCount += 1
         invokedAppExtensionDependenciesParameters = (path, name)
@@ -234,9 +234,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedResourceBundleDependenciesCount = 0
     var invokedResourceBundleDependenciesParameters: (path: AbsolutePath, name: String)? // swiftlint:disable:this identifier_name
     var invokedResourceBundleDependenciesParametersList = [(path: AbsolutePath, name: String)]() // swiftlint:disable:this identifier_name
-    var stubbedResourceBundleDependenciesResult: Set<ValueGraphTarget>! = []
+    var stubbedResourceBundleDependenciesResult: Set<GraphTarget>! = []
 
-    func resourceBundleDependencies(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    func resourceBundleDependencies(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         invokedResourceBundleDependencies = true
         invokedResourceBundleDependenciesCount += 1
         invokedResourceBundleDependenciesParameters = (path, name)
@@ -248,9 +248,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedTestTargetsDependingOnCount = 0
     var invokedTestTargetsDependingOnParameters: (path: AbsolutePath, name: String)?
     var invokedTestTargetsDependingOnParametersList = [(path: AbsolutePath, name: String)]() // swiftlint:disable:this identifier_name
-    var stubbedTestTargetsDependingOnResult: Set<ValueGraphTarget>! = []
+    var stubbedTestTargetsDependingOnResult: Set<GraphTarget>! = []
 
-    func testTargetsDependingOn(path: AbsolutePath, name: String) -> Set<ValueGraphTarget> {
+    func testTargetsDependingOn(path: AbsolutePath, name: String) -> Set<GraphTarget> {
         invokedTestTargetsDependingOn = true
         invokedTestTargetsDependingOnCount += 1
         invokedTestTargetsDependingOnParameters = (path, name)
@@ -276,9 +276,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedAppClipDependenciesCount = 0
     var invokedAppClipDependenciesParameters: (path: AbsolutePath, name: String)?
     var invokedAppClipDependenciesParametersList = [(path: AbsolutePath, name: String)]()
-    var stubbedAppClipDependenciesResult: ValueGraphTarget!
+    var stubbedAppClipDependenciesResult: GraphTarget!
 
-    func appClipDependencies(path: AbsolutePath, name: String) -> ValueGraphTarget? {
+    func appClipDependencies(path: AbsolutePath, name: String) -> GraphTarget? {
         invokedAppClipDependencies = true
         invokedAppClipDependenciesCount += 1
         invokedAppClipDependenciesParameters = (path, name)
@@ -392,9 +392,9 @@ final class MockGraphTraverser: GraphTraversing {
     var invokedHostTargetForCount = 0
     var invokedHostTargetForParameters: (path: AbsolutePath, name: String)?
     var invokedHostTargetForParametersList = [(path: AbsolutePath, name: String)]()
-    var stubbedHostTargetForResult: ValueGraphTarget!
+    var stubbedHostTargetForResult: GraphTarget!
 
-    func hostTargetFor(path: AbsolutePath, name: String) -> ValueGraphTarget? {
+    func hostTargetFor(path: AbsolutePath, name: String) -> GraphTarget? {
         invokedHostTargetFor = true
         invokedHostTargetForCount += 1
         invokedHostTargetForParameters = (path, name)

Sources/TuistCoreTesting/NodeLoaders/MockFrameworkNodeLoader.swift

@@ -6,12 +6,12 @@ import TuistGraph
 public final class MockFrameworkLoader: FrameworkLoading {
     public init() {}
 
-    var loadStub: ((AbsolutePath) throws -> ValueGraphDependency)?
-    public func load(path: AbsolutePath) throws -> ValueGraphDependency {
+    var loadStub: ((AbsolutePath) throws -> GraphDependency)?
+    public func load(path: AbsolutePath) throws -> GraphDependency {
         if let loadStub = loadStub {
             return try loadStub(path)
         } else {
-            return ValueGraphDependency.testFramework(path: path)
+            return GraphDependency.testFramework(path: path)
         }
     }
 }

Sources/TuistCoreTesting/NodeLoaders/MockXCFrameworkLoader.swift

@@ -6,8 +6,8 @@ import TuistGraph
 public final class MockXCFrameworkLoader: XCFrameworkLoading {
     public init() {}
 
-    var loadStub: ((AbsolutePath) throws -> ValueGraphDependency)?
-    public func load(path: AbsolutePath) throws -> ValueGraphDependency {
+    var loadStub: ((AbsolutePath) throws -> GraphDependency)?
+    public func load(path: AbsolutePath) throws -> GraphDependency {
         if let loadStub = loadStub {
             return try loadStub(path)
         } else {

Sources/TuistGenerator/Generator/SchemeDescriptorsGenerator.swift

@@ -634,7 +634,7 @@ final class SchemeDescriptorsGenerator: SchemeDescriptorsGenerating {
 
     // MARK: - Helpers
 
-    private func resolveRelativeProjectPath(graphTarget: ValueGraphTarget,
+    private func resolveRelativeProjectPath(graphTarget: GraphTarget,
                                             generatedProject _: GeneratedProject,
                                             rootPath: AbsolutePath) -> RelativePath
     {
@@ -649,7 +649,7 @@ final class SchemeDescriptorsGenerator: SchemeDescriptorsGenerating {
     ///     - graph: Tuist graph.
     ///     - rootPath: Path to the project or workspace.
     ///     - generatedProjects: Project paths mapped to generated projects.
-    private func createBuildableReference(graphTarget: ValueGraphTarget,
+    private func createBuildableReference(graphTarget: GraphTarget,
                                           graphTraverser: GraphTraversing,
                                           rootPath: AbsolutePath,
                                           generatedProjects: [AbsolutePath: GeneratedProject]) throws -> XCScheme.BuildableReference?
@@ -680,7 +680,7 @@ final class SchemeDescriptorsGenerator: SchemeDescriptorsGenerating {
     ///   - generatedProjects: Generated Xcode projects.
     ///   - rootPath: Root path to workspace or project.
     /// - Returns: Array of buildable references.
-    private func testCoverageTargetReferences(graphTarget: ValueGraphTarget,
+    private func testCoverageTargetReferences(graphTarget: GraphTarget,
                                               graphTraverser: GraphTraversing,
                                               generatedProjects: [AbsolutePath: GeneratedProject],
                                               rootPath: AbsolutePath) throws -> XCScheme.BuildableReference?

Sources/TuistGenerator/GraphViz/GraphToGraphVizMapper.swift

@@ -8,9 +8,9 @@ import TuistGraph
 public protocol GraphToGraphVizMapping {
     /// Maps the project graph into a dot graph representation.
     ///
-    /// - Parameter graph: ValueGraph to be converted into a GraphViz.Graph.
+    /// - Parameter graph: Graph to be converted into a GraphViz.Graph.
     /// - Returns: The GraphViz.Graph representation.
-    func map(graph: ValueGraph, skipTestTargets: Bool, skipExternalDependencies: Bool, targetsToFilter: [String]) -> GraphViz.Graph
+    func map(graph: TuistGraph.Graph, skipTestTargets: Bool, skipExternalDependencies: Bool, targetsToFilter: [String]) -> GraphViz.Graph
 }
 
 public final class GraphToGraphVizMapper: GraphToGraphVizMapping {
@@ -18,16 +18,16 @@ public final class GraphToGraphVizMapper: GraphToGraphVizMapping {
 
     /// Maps the project graph into a GraphViz graph representation.
     ///
-    /// - Parameter graph: ValueGraph to be converted into a GraphViz.Graph.
+    /// - Parameter graph: Graph to be converted into a GraphViz.Graph.
     /// - Returns: The GraphViz.Graph representation.
-    public func map(graph: ValueGraph, skipTestTargets: Bool, skipExternalDependencies: Bool, targetsToFilter: [String]) -> GraphViz.Graph {
+    public func map(graph: TuistGraph.Graph, skipTestTargets: Bool, skipExternalDependencies: Bool, targetsToFilter: [String]) -> GraphViz.Graph {
         var nodes: [GraphViz.Node] = []
         var dependencies: [GraphViz.Edge] = []
         var graphVizGraph = GraphViz.Graph(directed: true)
 
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
-        let filteredTargets: Set<ValueGraphTarget> = graphTraverser.allTargets().filter { target in
+        let filteredTargets: Set<GraphTarget> = graphTraverser.allTargets().filter { target in
             if skipTestTargets, graphTraverser.dependsOnXCTest(path: target.path, name: target.target.name) {
                 return false
             }
@@ -39,7 +39,7 @@ public final class GraphToGraphVizMapper: GraphToGraphVizMapping {
             return true
         }
 
-        let filteredTargetsAndDependencies: Set<ValueGraphTarget> = filteredTargets.union(
+        let filteredTargetsAndDependencies: Set<GraphTarget> = filteredTargets.union(
             transitiveClosure(Array(filteredTargets)) { target in
                 Array(graphTraverser.directTargetDependencies(path: target.path, name: target.target.name))
             }
@@ -79,7 +79,7 @@ public final class GraphToGraphVizMapper: GraphToGraphVizMapping {
     }
 }
 
-private extension ValueGraphDependency {
+private extension GraphDependency {
     var isExternal: Bool {
         switch self {
         case .target:

Sources/TuistGenerator/GraphViz/NodeStyling.swift

@@ -33,7 +33,7 @@ struct NodeStyleAttributes {
     }
 }
 
-extension ValueGraphTarget {
+extension GraphTarget {
     var styleAttributes: NodeStyleAttributes {
         switch target.product {
         case .app, .watch2App, .commandLineTool, .appClip:
@@ -58,7 +58,7 @@ extension ValueGraphTarget {
     }
 }
 
-extension ValueGraphDependency {
+extension GraphDependency {
     func styleAttributes(
         graphTraverser: GraphTraversing
     ) -> NodeStyleAttributes? {

Sources/TuistGenerator/Linter/GraphLinter.swift

@@ -54,8 +54,8 @@ public class GraphLinter: GraphLinting {
         var issues: [LintingIssue] = []
         let dependencyIssues = graphTraverser.dependencies.flatMap { (fromDependency, toDependencies) -> [LintingIssue] in
             toDependencies.flatMap { (toDependency) -> [LintingIssue] in
-                guard case let ValueGraphDependency.target(fromTargetName, fromTargetPath) = fromDependency else { return [] }
-                guard case let ValueGraphDependency.target(toTargetName, toTargetPath) = toDependency else { return [] }
+                guard case let GraphDependency.target(fromTargetName, fromTargetPath) = fromDependency else { return [] }
+                guard case let GraphDependency.target(toTargetName, toTargetPath) = toDependency else { return [] }
                 guard let fromTarget = graphTraverser.target(path: fromTargetPath, name: fromTargetName) else { return [] }
                 guard let toTarget = graphTraverser.target(path: toTargetPath, name: toTargetName) else { return [] }
                 return lintDependency(from: fromTarget, to: toTarget)
@@ -71,7 +71,7 @@ public class GraphLinter: GraphLinting {
         return issues
     }
 
-    private func lintDependency(from: ValueGraphTarget, to: ValueGraphTarget) -> [LintingIssue] {
+    private func lintDependency(from: GraphTarget, to: GraphTarget) -> [LintingIssue] {
         var issues: [LintingIssue] = []
 
         let fromTarget = LintableTarget(
@@ -201,7 +201,7 @@ public class GraphLinter: GraphLinting {
         return issues
     }
 
-    private func lint(watchApp: ValueGraphTarget, parentApp: ValueGraphTarget) -> [LintingIssue] {
+    private func lint(watchApp: GraphTarget, parentApp: GraphTarget) -> [LintingIssue] {
         guard watchApp.target.bundleId.hasPrefix(parentApp.target.bundleId) else {
             return [
                 LintingIssue(reason: """
@@ -212,7 +212,7 @@ public class GraphLinter: GraphLinting {
         return []
     }
 
-    private func lint(watchExtension: ValueGraphTarget, parentWatchApp: ValueGraphTarget) -> [LintingIssue] {
+    private func lint(watchExtension: GraphTarget, parentWatchApp: GraphTarget) -> [LintingIssue] {
         guard watchExtension.target.bundleId.hasPrefix(parentWatchApp.target.bundleId) else {
             return [
                 LintingIssue(reason: """
@@ -223,7 +223,7 @@ public class GraphLinter: GraphLinting {
         return []
     }
 
-    private func lint(appClip: ValueGraphTarget, parentApp: ValueGraphTarget) -> [LintingIssue] {
+    private func lint(appClip: GraphTarget, parentApp: GraphTarget) -> [LintingIssue] {
         var foundIssues = [LintingIssue]()
 
         if !appClip.target.bundleId.hasPrefix(parentApp.target.bundleId) {

Sources/TuistGenerator/Linter/StaticProductsGraphLinter.swift

@@ -19,7 +19,7 @@ class StaticProductsGraphLinter: StaticProductsGraphLinting {
             .map(lintIssue)
     }
 
-    private func warnings(in dependencies: [ValueGraphDependency], graphTraverser: GraphTraversing) -> Set<StaticDependencyWarning> {
+    private func warnings(in dependencies: [GraphDependency], graphTraverser: GraphTraversing) -> Set<StaticDependencyWarning> {
         var warnings = Set<StaticDependencyWarning>()
         let cache = Cache()
         dependencies.forEach { dependency in
@@ -58,7 +58,7 @@ class StaticProductsGraphLinter: StaticProductsGraphLinting {
     /// - In the event a node is a node capable of linking static products, it removes all the nodes
     ///   from the unlinked bucket and places them in the linked bucket in format of _staticNode > [linkingNode]_.
     ///
-    private func buildStaticProductsMap(visiting dependency: ValueGraphDependency,
+    private func buildStaticProductsMap(visiting dependency: GraphDependency,
                                         graphTraverser: GraphTraversing,
                                         cache: Cache) -> StaticProducts
     {
@@ -79,7 +79,7 @@ class StaticProductsGraphLinter: StaticProductsGraphLinting {
         }
 
         // Linking node case
-        guard case let ValueGraphDependency.target(targetName, targetPath) = dependency,
+        guard case let GraphDependency.target(targetName, targetPath) = dependency,
             let dependencyTarget = graphTraverser.target(path: targetPath, name: targetName),
             dependencyTarget.target.canLinkStaticProducts()
         else {
@@ -98,21 +98,21 @@ class StaticProductsGraphLinter: StaticProductsGraphLinting {
         return results
     }
 
-    private func staticDependencyWarning(staticProduct: ValueGraphDependency,
-                                         linkedBy: Set<ValueGraphDependency>,
+    private func staticDependencyWarning(staticProduct: GraphDependency,
+                                         linkedBy: Set<GraphDependency>,
                                          graphTraverser: GraphTraversing) -> [StaticDependencyWarning]
     {
         // Common dependencies between test bundles and their host apps are automatically omitted
         // during generation - as such those shouldn't be flagged
         //
         // reference: https://github.com/tuist/tuist/pull/664
-        let apps: Set<ValueGraphDependency> = linkedBy.filter { (dependency) -> Bool in
-            guard case let ValueGraphDependency.target(targetName, targetPath) = dependency else { return false }
+        let apps: Set<GraphDependency> = linkedBy.filter { (dependency) -> Bool in
+            guard case let GraphDependency.target(targetName, targetPath) = dependency else { return false }
             guard let target = graphTraverser.target(path: targetPath, name: targetName) else { return false }
             return target.target.product == .app
         }
         let hostedTestBundles = linkedBy.filter { (dependency) -> Bool in
-            guard case let ValueGraphDependency.target(targetName, targetPath) = dependency else { return false }
+            guard case let GraphDependency.target(targetName, targetPath) = dependency else { return false }
             guard let target = graphTraverser.target(path: targetPath, name: targetName) else { return false }
 
             let isTestsBundle = target.target.product.testsBundle
@@ -134,7 +134,7 @@ class StaticProductsGraphLinter: StaticProductsGraphLinting {
         ]
     }
 
-    private func isStaticProduct(_ dependency: ValueGraphDependency, graphTraverser: GraphTraversing) -> Bool {
+    private func isStaticProduct(_ dependency: GraphDependency, graphTraverser: GraphTraversing) -> Bool {
         switch dependency {
         case let .xcframework(_, _, _, linking):
             return linking == .static
@@ -155,14 +155,14 @@ class StaticProductsGraphLinter: StaticProductsGraphLinting {
         }
     }
 
-    private func dependencies(for dependency: ValueGraphDependency, graphTraverser: GraphTraversing) -> [ValueGraphDependency] {
+    private func dependencies(for dependency: GraphDependency, graphTraverser: GraphTraversing) -> [GraphDependency] {
         Array(graphTraverser.dependencies[dependency, default: Set()])
             .filter { canVisit(dependency: $0, from: dependency, graphTraverser: graphTraverser) }
     }
 
-    private func canVisit(dependency: ValueGraphDependency, from: ValueGraphDependency, graphTraverser: GraphTraversing) -> Bool {
-        guard case let ValueGraphDependency.target(fromTargetName, fromTargetPath) = from else { return true }
-        guard case let ValueGraphDependency.target(toTargetName, toTargetPath) = dependency else { return true }
+    private func canVisit(dependency: GraphDependency, from: GraphDependency, graphTraverser: GraphTraversing) -> Bool {
+        guard case let GraphDependency.target(fromTargetName, fromTargetPath) = from else { return true }
+        guard case let GraphDependency.target(toTargetName, toTargetPath) = dependency else { return true }
 
         guard let fromTarget = graphTraverser.target(path: fromTargetPath, name: fromTargetName) else { return false }
         guard let toTarget = graphTraverser.target(path: toTargetPath, name: toTargetName) else { return false }
@@ -208,8 +208,8 @@ class StaticProductsGraphLinter: StaticProductsGraphLinting {
 
 extension StaticProductsGraphLinter {
     private struct StaticDependencyWarning: Hashable, Comparable {
-        var staticProduct: ValueGraphDependency
-        var linkingDependencies: [ValueGraphDependency]
+        var staticProduct: GraphDependency
+        var linkingDependencies: [GraphDependency]
 
         var debugDescription: String {
             stringDescription
@@ -228,13 +228,13 @@ extension StaticProductsGraphLinter {
 
     private struct StaticProducts {
         // Unlinked static products
-        var unlinked: Set<ValueGraphDependency> = Set()
+        var unlinked: Set<GraphDependency> = Set()
 
         // Map of Static product to nodes that link it
         // e.g.
         //    - MyStaticFrameworkA > [MyDynamicFrameworkA, MyTestsTarget]
         //    - MyStaticFrameworkB > [MyDynamicFrameworkA, MyTestsTarget]
-        var linked: [ValueGraphDependency: Set<ValueGraphDependency>] = [:]
+        var linked: [GraphDependency: Set<GraphDependency>] = [:]
 
         func merged(with other: StaticProducts) -> StaticProducts {
             StaticProducts(
@@ -245,14 +245,14 @@ extension StaticProductsGraphLinter {
     }
 
     private class Cache {
-        private var cachedResults: [ValueGraphDependency: StaticProducts] = [:]
+        private var cachedResults: [GraphDependency: StaticProducts] = [:]
 
-        func results(for dependency: ValueGraphDependency) -> StaticProducts? {
+        func results(for dependency: GraphDependency) -> StaticProducts? {
             cachedResults[dependency]
         }
 
         func cache(results: StaticProducts,
-                   for dependency: ValueGraphDependency)
+                   for dependency: GraphDependency)
         {
             cachedResults[dependency] = results
         }

Sources/TuistGraph/Graph/Graph.swift

@@ -2,7 +2,7 @@ import Foundation
 import TSCBasic
 
 /// A directed acyclic graph (DAG) that Tuist uses to represent the dependency tree.
-public struct ValueGraph: Equatable, Codable {
+public struct Graph: Equatable, Codable {
     /// The name of the graph
     public var name: String
 
@@ -25,7 +25,7 @@ public struct ValueGraph: Equatable, Codable {
     public var targets: [AbsolutePath: [String: Target]]
 
     /// A dictionary that contains the one-to-many dependencies that represent the graph.
-    public var dependencies: [ValueGraphDependency: Set<ValueGraphDependency>]
+    public var dependencies: [GraphDependency: Set<GraphDependency>]
 
     public init(name: String,
                 path: AbsolutePath,
@@ -33,7 +33,7 @@ public struct ValueGraph: Equatable, Codable {
                 projects: [AbsolutePath: Project],
                 packages: [AbsolutePath: [String: Package]],
                 targets: [AbsolutePath: [String: Target]],
-                dependencies: [ValueGraphDependency: Set<ValueGraphDependency>])
+                dependencies: [GraphDependency: Set<GraphDependency>])
     {
         self.name = name
         self.path = path

Sources/TuistGraph/Graph/GraphDependency.swift

@@ -2,7 +2,7 @@ import Foundation
 import TSCBasic
 
 // swiftlint:disable:next type_body_length
-public enum ValueGraphDependency: Hashable, CustomStringConvertible, Comparable, Codable {
+public enum GraphDependency: Hashable, CustomStringConvertible, Comparable, Codable {
     /// A dependency that represents a pre-compiled .xcframework.
     case xcframework(
         path: AbsolutePath,
@@ -132,7 +132,7 @@ public enum ValueGraphDependency: Hashable, CustomStringConvertible, Comparable,
 
     // MARK: - Comparable
 
-    public static func < (lhs: ValueGraphDependency, rhs: ValueGraphDependency) -> Bool {
+    public static func < (lhs: GraphDependency, rhs: GraphDependency) -> Bool {
         lhs.description < rhs.description
     }
 

Sources/TuistGraph/Graph/GraphTarget.swift

@@ -1,7 +1,7 @@
 import Foundation
 import TSCBasic
 
-public struct ValueGraphTarget: Equatable, Hashable, Comparable, CustomDebugStringConvertible, CustomStringConvertible, Codable {
+public struct GraphTarget: Equatable, Hashable, Comparable, CustomDebugStringConvertible, CustomStringConvertible, Codable {
     /// Path to the directory that contains the project where the target is defined.
     public let path: AbsolutePath
 
@@ -17,7 +17,7 @@ public struct ValueGraphTarget: Equatable, Hashable, Comparable, CustomDebugStri
         self.project = project
     }
 
-    public static func < (lhs: ValueGraphTarget, rhs: ValueGraphTarget) -> Bool {
+    public static func < (lhs: GraphTarget, rhs: GraphTarget) -> Bool {
         (lhs.path, lhs.target) < (rhs.path, rhs.target)
     }
 

Sources/TuistGraphTesting/Graph/Graph+TestData.swift

@@ -2,16 +2,16 @@ import Foundation
 import TSCBasic
 import TuistGraph
 
-public extension ValueGraph {
+public extension Graph {
     static func test(name: String = "graph",
                      path: AbsolutePath = .root,
                      workspace: Workspace = .test(),
                      projects: [AbsolutePath: Project] = [:],
                      packages: [AbsolutePath: [String: Package]] = [:],
                      targets: [AbsolutePath: [String: Target]] = [:],
-                     dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [:]) -> ValueGraph
+                     dependencies: [GraphDependency: Set<GraphDependency>] = [:]) -> Graph
     {
-        ValueGraph(
+        Graph(
             name: name,
             path: path,
             workspace: workspace,

Sources/TuistGraphTesting/Graph/GraphDependency+TestData.swift

@@ -3,9 +3,9 @@ import TSCBasic
 
 @testable import TuistGraph
 
-public extension ValueGraphDependency {
-    static func testCocoapods(path: AbsolutePath = .root) -> ValueGraphDependency {
-        ValueGraphDependency.cocoapods(path: path)
+public extension GraphDependency {
+    static func testCocoapods(path: AbsolutePath = .root) -> GraphDependency {
+        GraphDependency.cocoapods(path: path)
     }
 
     static func testFramework(path: AbsolutePath = AbsolutePath.root.appending(component: "Test.framework"),
@@ -14,9 +14,9 @@ public extension ValueGraphDependency {
                               bcsymbolmapPaths: [AbsolutePath] = [],
                               linking: BinaryLinking = .dynamic,
                               architectures: [BinaryArchitecture] = [.armv7],
-                              isCarthage: Bool = false) -> ValueGraphDependency
+                              isCarthage: Bool = false) -> GraphDependency
     {
-        ValueGraphDependency.framework(
+        GraphDependency.framework(
             path: path,
             binaryPath: binaryPath,
             dsymPath: dsymPath,
@@ -30,7 +30,7 @@ public extension ValueGraphDependency {
     static func testXCFramework(path: AbsolutePath = AbsolutePath.root.appending(RelativePath("Test.xcframework")),
                                 infoPlist: XCFrameworkInfoPlist = .test(),
                                 primaryBinaryPath: AbsolutePath = AbsolutePath.root.appending(RelativePath("Test.xcframework/Test")),
-                                linking: BinaryLinking = .dynamic) -> ValueGraphDependency
+                                linking: BinaryLinking = .dynamic) -> GraphDependency
     {
         .xcframework(
             path: path,
@@ -41,7 +41,7 @@ public extension ValueGraphDependency {
     }
 
     static func testTarget(name: String = "Test",
-                           path: AbsolutePath = .root) -> ValueGraphDependency
+                           path: AbsolutePath = .root) -> GraphDependency
     {
         .target(
             name: name,
@@ -52,7 +52,7 @@ public extension ValueGraphDependency {
     static func testSDK(name: String = "XCTest",
                         path: AbsolutePath = AbsolutePath.root.appending(RelativePath("XCTest.framework")),
                         status: SDKStatus = .required,
-                        source: SDKSource = .system) -> ValueGraphDependency
+                        source: SDKSource = .system) -> GraphDependency
     {
         .sdk(
             name: name,
@@ -66,7 +66,7 @@ public extension ValueGraphDependency {
                             publicHeaders: AbsolutePath = AbsolutePath.root.appending(RelativePath("headers")),
                             linking: BinaryLinking = .dynamic,
                             architectures: [BinaryArchitecture] = [.armv7],
-                            swiftModuleMap: AbsolutePath? = nil) -> ValueGraphDependency
+                            swiftModuleMap: AbsolutePath? = nil) -> GraphDependency
     {
         .library(
             path: path,
@@ -78,7 +78,7 @@ public extension ValueGraphDependency {
     }
 
     static func testPackageProduct(path: AbsolutePath = .root,
-                                   product: String = "Tuist") -> ValueGraphDependency
+                                   product: String = "Tuist") -> GraphDependency
     {
         .packageProduct(
             path: path,

Sources/TuistGraphTesting/Graph/GraphTarget+TestData.swift

@@ -3,12 +3,12 @@ import TSCBasic
 
 @testable import TuistGraph
 
-public extension ValueGraphTarget {
+public extension GraphTarget {
     static func test(path: AbsolutePath = .root,
                      target: Target = .test(),
-                     project: Project = .test()) -> ValueGraphTarget
+                     project: Project = .test()) -> GraphTarget
     {
-        ValueGraphTarget(
+        GraphTarget(
             path: path,
             target: target,
             project: project

Sources/TuistKit/Cache/CacheController.swift

@@ -120,7 +120,7 @@ final class CacheController: CacheControlling {
             cacheOutputType: artifactBuilder.cacheOutputType
         )
 
-        let filteredTargets: [ValueGraphTarget]
+        let filteredTargets: [GraphTarget]
         if targetsToFilter.isEmpty {
             filteredTargets = Array(hashesByCacheableTarget.keys)
         } else {
@@ -129,7 +129,7 @@ final class CacheController: CacheControlling {
 
         logger.notice("Building cacheable targets")
 
-        let graphTraveser = ValueGraphTraverser(graph: graph)
+        let graphTraveser = GraphTraverser(graph: graph)
         let sortedCacheableTargets = try topologicalSort(
             filteredTargets,
             successors: {
@@ -161,7 +161,7 @@ final class CacheController: CacheControlling {
     ///   - configuration: The configuration.
     ///   - hash: Hash of the target.
     fileprivate func buildAndCacheFramework(path: AbsolutePath,
-                                            target: ValueGraphTarget,
+                                            target: GraphTarget,
                                             configuration: String,
                                             hash: String) throws
     {

Sources/TuistKit/Generator/Generator.swift

@@ -10,11 +10,11 @@ import TuistSupport
 
 protocol Generating {
     @discardableResult
-    func load(path: AbsolutePath) throws -> ValueGraph
-    func loadProject(path: AbsolutePath) throws -> (Project, ValueGraph, [SideEffectDescriptor]) // swiftlint:disable:this large_tuple
+    func load(path: AbsolutePath) throws -> Graph
+    func loadProject(path: AbsolutePath) throws -> (Project, Graph, [SideEffectDescriptor]) // swiftlint:disable:this large_tuple
     func generate(path: AbsolutePath, projectOnly: Bool) throws -> AbsolutePath
-    func generateWithGraph(path: AbsolutePath, projectOnly: Bool) throws -> (AbsolutePath, ValueGraph)
-    func generateProjectWorkspace(path: AbsolutePath) throws -> (AbsolutePath, ValueGraph)
+    func generateWithGraph(path: AbsolutePath, projectOnly: Bool) throws -> (AbsolutePath, Graph)
+    func generateProjectWorkspace(path: AbsolutePath) throws -> (AbsolutePath, Graph)
 }
 
 class Generator: Generating {
@@ -74,7 +74,7 @@ class Generator: Generating {
         return generatedPath
     }
 
-    func generateWithGraph(path: AbsolutePath, projectOnly: Bool) throws -> (AbsolutePath, ValueGraph) {
+    func generateWithGraph(path: AbsolutePath, projectOnly: Bool) throws -> (AbsolutePath, Graph) {
         let manifests = manifestLoader.manifests(at: path)
 
         if projectOnly {
@@ -88,7 +88,7 @@ class Generator: Generating {
         }
     }
 
-    func load(path: AbsolutePath) throws -> ValueGraph {
+    func load(path: AbsolutePath) throws -> Graph {
         let manifests = manifestLoader.manifests(at: path)
 
         if manifests.contains(.workspace) {
@@ -101,7 +101,7 @@ class Generator: Generating {
     }
 
     // swiftlint:disable:next large_tuple
-    func loadProject(path: AbsolutePath) throws -> (Project, ValueGraph, [SideEffectDescriptor]) {
+    func loadProject(path: AbsolutePath) throws -> (Project, Graph, [SideEffectDescriptor]) {
         // Load config
         let config = try configLoader.loadConfig(path: path)
 
@@ -127,7 +127,7 @@ class Generator: Generating {
         let modelMapperSideEffects = updatedModels.flatMap(\.1)
 
         // Load Graph
-        let graphLoader = ValueGraphLoader()
+        let graphLoader = GraphLoader()
         let (project, graph) = try graphLoader.loadProject(
             at: path,
             projects: updatedProjects
@@ -141,10 +141,10 @@ class Generator: Generating {
         return (project, updatedGraph, modelMapperSideEffects + graphMapperSideEffects)
     }
 
-    private func generateProject(path: AbsolutePath) throws -> (AbsolutePath, ValueGraph) {
+    private func generateProject(path: AbsolutePath) throws -> (AbsolutePath, Graph) {
         // Load
         let (project, graph, sideEffects) = try loadProject(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Lint
         try lint(graphTraverser: graphTraverser)
@@ -164,10 +164,10 @@ class Generator: Generating {
         return (projectDescriptor.xcodeprojPath, graph)
     }
 
-    private func generateWorkspace(path: AbsolutePath) throws -> (AbsolutePath, ValueGraph) {
+    private func generateWorkspace(path: AbsolutePath) throws -> (AbsolutePath, Graph) {
         // Load
         let (graph, sideEffects) = try loadWorkspace(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Lint
         try lint(graphTraverser: graphTraverser)
@@ -187,10 +187,10 @@ class Generator: Generating {
         return (workspaceDescriptor.xcworkspacePath, graph)
     }
 
-    internal func generateProjectWorkspace(path: AbsolutePath) throws -> (AbsolutePath, ValueGraph) {
+    internal func generateProjectWorkspace(path: AbsolutePath) throws -> (AbsolutePath, Graph) {
         // Load
         let (_, graph, sideEffects) = try loadProjectWorkspace(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Lint
         try lint(graphTraverser: graphTraverser)
@@ -226,7 +226,7 @@ class Generator: Generating {
     }
 
     // swiftlint:disable:next large_tuple
-    private func loadProjectWorkspace(path: AbsolutePath) throws -> (Project, ValueGraph, [SideEffectDescriptor]) {
+    private func loadProjectWorkspace(path: AbsolutePath) throws -> (Project, Graph, [SideEffectDescriptor]) {
         // Load config
         let config = try configLoader.loadConfig(path: path)
 
@@ -261,7 +261,7 @@ class Generator: Generating {
         )
 
         // Load Graph
-        let graphLoader = ValueGraphLoader()
+        let graphLoader = GraphLoader()
         var (project, graph) = try graphLoader.loadProject(
             at: path,
             projects: updatedModels.projects
@@ -284,7 +284,7 @@ class Generator: Generating {
         )
     }
 
-    private func loadWorkspace(path: AbsolutePath) throws -> (ValueGraph, [SideEffectDescriptor]) {
+    private func loadWorkspace(path: AbsolutePath) throws -> (Graph, [SideEffectDescriptor]) {
         // Load config
         let config = try configLoader.loadConfig(path: path)
 
@@ -310,7 +310,7 @@ class Generator: Generating {
         )
 
         // Load Graph
-        let graphLoader = ValueGraphLoader()
+        let graphLoader = GraphLoader()
         let graph = try graphLoader.loadWorkspace(
             workspace: updatedModels.workspace,
             projects: updatedModels.projects

Sources/TuistKit/GraphMappers/UpdateWorkspaceProjectsGraphMapper.swift

@@ -5,7 +5,7 @@ import TuistGraph
 /// A mapper that ensures that the list of projects of the workspace is in sync
 /// with the projects available in the graph.
 final class UpdateWorkspaceProjectsGraphMapper: GraphMapping {
-    func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor]) {
+    func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor]) {
         var graph = graph
         let graphProjects = Set(graph.projects.map(\.key))
         let workspaceProjects = Set(graph.workspace.projects).intersection(graphProjects)

Sources/TuistKit/ProjectEditor/ProjectEditor.swift

@@ -150,7 +150,7 @@ final class ProjectEditor: ProjectEditing {
             projectAutomationPath: try resourceLocator.projectAutomation()
         )
 
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let descriptor = try generator.generateWorkspace(graphTraverser: graphTraverser)
         try writer.write(workspace: descriptor)
         return descriptor.xcworkspacePath

Sources/TuistKit/ProjectEditor/ProjectEditorMapper.swift

@@ -22,7 +22,7 @@ protocol ProjectEditorMapping: AnyObject {
         tasks: [AbsolutePath],
         projectDescriptionPath: AbsolutePath,
         projectAutomationPath: AbsolutePath
-    ) throws -> ValueGraph
+    ) throws -> Graph
 }
 
 // swiftlint:disable:next type_body_length
@@ -44,7 +44,7 @@ final class ProjectEditorMapper: ProjectEditorMapping {
         tasks: [AbsolutePath],
         projectDescriptionPath: AbsolutePath,
         projectAutomationPath: AbsolutePath
-    ) throws -> ValueGraph {
+    ) throws -> Graph {
         let swiftVersion = try System.shared.swiftVersion()
 
         let pluginsProject = mapPluginsProject(
@@ -92,9 +92,9 @@ final class ProjectEditorMapper: ProjectEditorMapping {
 
         let graphDependencies = projects
             .lazy
-            .flatMap { project -> [(ValueGraphDependency, Set<ValueGraphDependency>)] in
+            .flatMap { project -> [(GraphDependency, Set<GraphDependency>)] in
                 let graphDependencies = project.targets.map(\.dependencies).lazy.map { dependencies in
-                    dependencies.lazy.compactMap { dependency -> ValueGraphDependency? in
+                    dependencies.lazy.compactMap { dependency -> GraphDependency? in
                         switch dependency {
                         case let .target(name):
                             if let pluginsProject = pluginsProject, editablePluginManifests.contains(where: { $0.name == name }) {
@@ -109,11 +109,11 @@ final class ProjectEditorMapper: ProjectEditorMapping {
                 }
 
                 return zip(project.targets, graphDependencies).map { target, dependencies in
-                    (ValueGraphDependency.target(name: target.name, path: project.path), Set(dependencies))
+                    (GraphDependency.target(name: target.name, path: project.path), Set(dependencies))
                 }
             }
 
-        return ValueGraph(
+        return Graph(
             name: name,
             path: sourceRootPath,
             workspace: workspace,

Sources/TuistKit/Services/BuildService.swift

@@ -56,7 +56,7 @@ final class BuildService {
         buildOutputPath: AbsolutePath?,
         path: AbsolutePath
     ) throws {
-        let graph: ValueGraph
+        let graph: Graph
         if try (generate || buildGraphInspector.workspacePath(directory: path) == nil) {
             graph = try generator.generateWithGraph(path: path, projectOnly: false).1
         } else {
@@ -67,7 +67,7 @@ final class BuildService {
             throw BuildServiceError.workspaceNotFound(path: path.pathString)
         }
 
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let buildableSchemes = buildGraphInspector.buildableSchemes(graphTraverser: graphTraverser)
 
         logger.log(level: .debug, "Found the following buildable schemes: \(buildableSchemes.map(\.name).joined(separator: ", "))")

Sources/TuistKit/Services/DocService.swift

@@ -78,7 +78,7 @@ final class DocService {
 
     func run(project path: AbsolutePath, target targetName: String) throws {
         let graph = try generator.load(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         let targets = graphTraverser.allTargets()
             .filter { !graphTraverser.dependsOnXCTest(path: $0.path, name: $0.target.name) }

Sources/TuistKit/Services/Lint/LintCodeService.swift

@@ -65,7 +65,7 @@ final class LintCodeService {
         let graph = try manifestGraphLoader.loadGraph(at: path)
 
         // Get sources
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let sources = try getSources(targetName: targetName, graphTraverser: graphTraverser)
 
         // Lint code

Sources/TuistKit/Services/Lint/LintProjectService.swift

@@ -65,7 +65,7 @@ final class LintProjectService {
 
         logger.notice("Loading the dependency graph at \(path)")
         let graph = try manifestGraphLoader.loadGraph(at: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         logger.notice("Running linters")
 

Sources/TuistKit/Services/RunService.swift

@@ -73,7 +73,7 @@ final class RunService {
             runPath = FileHandler.shared.currentPath
         }
 
-        let graph: ValueGraph
+        let graph: Graph
         if try (generate || buildGraphInspector.workspacePath(directory: runPath) == nil) {
             logger.notice("Generating project for running", metadata: .section)
             graph = try generator.generateWithGraph(path: runPath, projectOnly: false).1
@@ -85,7 +85,7 @@ final class RunService {
             throw RunServiceError.workspaceNotFound(path: runPath.pathString)
         }
 
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let runnableSchemes = buildGraphInspector.runnableSchemes(graphTraverser: graphTraverser)
 
         logger.debug("Found the following runnable schemes: \(runnableSchemes.map(\.name).joined(separator: ", "))")

Sources/TuistKit/Services/TestService.swift

@@ -102,7 +102,7 @@ final class TestService {
             path: path,
             projectOnly: false
         ).1
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let version = osVersion?.version()
 
         let testableSchemes = buildGraphInspector.testableSchemes(graphTraverser: graphTraverser) +

Sources/TuistKit/Utils/ManifestGraphLoader.swift

@@ -17,7 +17,7 @@ import TuistSupport
 protocol ManifestGraphLoading {
     /// Loads a Workspace or Project Graph at a given path based on manifest availability
     /// - Note: This will search for a Workspace manifest first, then fallback to searching for a Project manifest
-    func loadGraph(at path: AbsolutePath) throws -> ValueGraph
+    func loadGraph(at path: AbsolutePath) throws -> Graph
 }
 
 final class ManifestGraphLoader: ManifestGraphLoading {
@@ -25,7 +25,7 @@ final class ManifestGraphLoader: ManifestGraphLoading {
     private let manifestLoader: ManifestLoading
     private let recursiveManifestLoader: RecursiveManifestLoader
     private let converter: ManifestModelConverting
-    private let graphLoader: ValueGraphLoading
+    private let graphLoader: GraphLoading
     private let pluginsService: PluginServicing
 
     convenience init(manifestLoader: ManifestLoading) {
@@ -36,7 +36,7 @@ final class ManifestGraphLoader: ManifestGraphLoading {
             converter: ManifestModelConverter(
                 manifestLoader: manifestLoader
             ),
-            graphLoader: ValueGraphLoader(),
+            graphLoader: GraphLoader(),
             pluginsService: PluginService(manifestLoader: manifestLoader)
         )
     }
@@ -46,7 +46,7 @@ final class ManifestGraphLoader: ManifestGraphLoading {
         manifestLoader: ManifestLoading,
         recursiveManifestLoader: RecursiveManifestLoader,
         converter: ManifestModelConverting,
-        graphLoader: ValueGraphLoading,
+        graphLoader: GraphLoading,
         pluginsService: PluginServicing
     ) {
         self.configLoader = configLoader
@@ -57,7 +57,7 @@ final class ManifestGraphLoader: ManifestGraphLoading {
         self.pluginsService = pluginsService
     }
 
-    func loadGraph(at path: AbsolutePath) throws -> ValueGraph {
+    func loadGraph(at path: AbsolutePath) throws -> Graph {
         let manifests = manifestLoader.manifests(at: path)
         if manifests.contains(.workspace) {
             return try loadWorkspaceGraph(at: path)
@@ -78,14 +78,14 @@ final class ManifestGraphLoader: ManifestGraphLoading {
 
     // MARK: - Private
 
-    private func loadProjectGraph(at path: AbsolutePath) throws -> (Project, ValueGraph) {
+    private func loadProjectGraph(at path: AbsolutePath) throws -> (Project, Graph) {
         let plugins = try loadPlugins(at: path)
         let manifests = try recursiveManifestLoader.loadProject(at: path)
         let models = try convert(manifests: manifests, plugins: plugins)
         return try graphLoader.loadProject(at: path, projects: models)
     }
 
-    private func loadWorkspaceGraph(at path: AbsolutePath) throws -> ValueGraph {
+    private func loadWorkspaceGraph(at path: AbsolutePath) throws -> Graph {
         let plugins = try loadPlugins(at: path)
         let manifests = try recursiveManifestLoader.loadWorkspace(at: path)
         let models = try convert(manifests: manifests, plugins: plugins)

Sources/TuistSigning/SigningInteractor.swift

@@ -82,7 +82,7 @@ public final class SigningInteractor: SigningInteracting {
 
     // MARK: - Helpers
 
-    private func install(target: ValueGraphTarget,
+    private func install(target: GraphTarget,
                          keychainPath: AbsolutePath,
                          certificates: [Fingerprint: Certificate],
                          provisioningProfiles: [TargetName: [ConfigurationName: ProvisioningProfile]]) throws

Tests/TuistAutomationTests/Utilities/BuildGraphInspectorTests.swift

@@ -138,11 +138,11 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
         let scheme = Scheme.test(buildAction: .test(targets: [.init(projectPath: projectPath, name: "Core")]))
         let target = Target.test(name: "Core")
         let project = Project.test(path: projectPath)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [projectPath: project],
             targets: [projectPath: [target.name: target]]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.buildableTarget(scheme: scheme, graphTraverser: graphTraverser)
@@ -171,14 +171,14 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
             )
         )
         let workspace = Workspace.test(schemes: [workspaceScheme])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             workspace: workspace,
             projects: [
                 coreProject.path: coreProject,
                 kitProject.path: kitProject,
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.buildableSchemes(graphTraverser: graphTraverser)
@@ -228,7 +228,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
             path: coreProjectPath,
             schemes: [coreScheme, coreTestsScheme]
         )
-        let coreValueGraphTarget = ValueGraphTarget.test(
+        let coreGraphTarget = GraphTarget.test(
             target: coreTarget,
             project: coreProject
         )
@@ -237,7 +237,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
             product: .unitTests,
             dependencies: [.target(name: "Core")]
         )
-        let coreTestsValueGraphTarget = ValueGraphTarget.test(
+        let coreTestsGraphTarget = GraphTarget.test(
             target: coreTestsTarget,
             project: coreProject
         )
@@ -246,7 +246,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
             path: projectPath,
             schemes: [kitScheme, kitTestsScheme]
         )
-        let kitValueGraphTarget = ValueGraphTarget.test(
+        let kitGraphTarget = GraphTarget.test(
             target: kitTarget,
             project: kitProject
         )
@@ -255,27 +255,27 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
             product: .unitTests,
             dependencies: [.target(name: "Kit")]
         )
-        let kitTestsValueGraphTarget = ValueGraphTarget.test(
+        let kitTestsGraphTarget = GraphTarget.test(
             target: kitTestsTarget,
             project: kitProject
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 kitProject.path: kitProject,
                 coreProject.path: coreProject,
             ],
             targets: [
                 projectPath: [
-                    kitValueGraphTarget.target.name: kitValueGraphTarget.target,
-                    kitTestsValueGraphTarget.target.name: kitTestsValueGraphTarget.target,
+                    kitGraphTarget.target.name: kitGraphTarget.target,
+                    kitTestsGraphTarget.target.name: kitTestsGraphTarget.target,
                 ],
                 coreProjectPath: [
-                    coreValueGraphTarget.target.name: coreValueGraphTarget.target,
-                    coreTestsValueGraphTarget.target.name: coreTestsValueGraphTarget.target,
+                    coreGraphTarget.target.name: coreGraphTarget.target,
+                    coreTestsGraphTarget.target.name: coreTestsGraphTarget.target,
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.testSchemes(graphTraverser: graphTraverser)
@@ -312,21 +312,21 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
             path: coreProjectPath,
             schemes: [coreScheme, coreTestsScheme]
         )
-        let coreValueGraphTarget = ValueGraphTarget.test(
+        let coreGraphTarget = GraphTarget.test(
             target: coreTarget,
             project: coreProject
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 coreProject.path: coreProject,
             ],
             targets: [
                 coreProject.path: [
-                    coreValueGraphTarget.target.name: coreValueGraphTarget.target,
+                    coreGraphTarget.target.name: coreGraphTarget.target,
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.testableSchemes(graphTraverser: graphTraverser)
@@ -355,7 +355,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
         let projectB = Project.test(path: projectBPath, schemes: [schemeB])
         let targetB = Target.test(name: "B")
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             workspace: Workspace.test(projects: [projectA.path]),
             projects: [
                 projectA.path: projectA,
@@ -363,7 +363,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
             ],
             targets: [projectAPath: [targetA.name: targetA], projectBPath: [targetB.name: targetB]]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.buildableEntrySchemes(graphTraverser: graphTraverser)
@@ -417,7 +417,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
 
     func test_projectSchemes_when_multiple_platforms() {
         // Given
-        let graph: ValueGraph = .test(
+        let graph: Graph = .test(
             workspace: .test(
                 name: "WorkspaceName",
                 schemes: [
@@ -427,7 +427,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
                 ]
             )
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.projectSchemes(graphTraverser: graphTraverser)
@@ -444,7 +444,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
 
     func test_projectSchemes_when_single_platform() {
         // Given
-        let graph: ValueGraph = .test(
+        let graph: Graph = .test(
             workspace: .test(
                 name: "WorkspaceName",
                 schemes: [
@@ -453,7 +453,7 @@ final class BuildGraphInspectorTests: TuistUnitTestCase {
                 ]
             )
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.projectSchemes(graphTraverser: graphTraverser)

Tests/TuistAutomationTests/Utilities/TargetRunnerTests.swift

@@ -57,7 +57,7 @@ final class TargetRunnerTests: TuistUnitTestCase {
 
     func test_throwsError_when_buildProductNotFound() throws {
         // Given
-        let target = ValueGraphTarget.test()
+        let target = GraphTarget.test()
         let path = try temporaryPath()
         let workspacePath = path.appending(component: "App.xcworkspace")
         let outputPath = path.appending(component: ".build")
@@ -115,7 +115,7 @@ final class TargetRunnerTests: TuistUnitTestCase {
         // Given
         let workspacePath = try temporaryPath().appending(component: "App.xcworkspace")
         let target = Target.test(platform: .macOS, product: .commandLineTool)
-        let graphTarget = ValueGraphTarget.test(path: workspacePath, target: target, project: .test())
+        let graphTarget = GraphTarget.test(path: workspacePath, target: target, project: .test())
         let outputPath = try temporaryPath().appending(component: ".build")
         let executablePath = outputPath.appending(component: target.productNameWithExtension)
         let arguments = ["Argument", "--option1", "AnotherArgument", "--option2=true", "-opt3"]
@@ -144,7 +144,7 @@ final class TargetRunnerTests: TuistUnitTestCase {
         // Given
         let workspacePath = try temporaryPath().appending(component: "App.xcworkspace")
         let target = Target.test(platform: .iOS, product: .app)
-        let graphTarget = ValueGraphTarget.test(path: workspacePath, target: target, project: .test())
+        let graphTarget = GraphTarget.test(path: workspacePath, target: target, project: .test())
         let outputPath = try temporaryPath().appending(component: ".build")
         let appPath = outputPath.appending(component: target.productNameWithExtension)
         let arguments = ["Argument", "--option1", "AnotherArgument", "--option2=true", "-opt3"]

Tests/TuistCacheIntegrationTests/ContentHashing/ContentHashingIntegrationTests.swift

@@ -70,7 +70,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, sources: [source1, source2])
         let framework2 = makeFramework(project: project2, sources: [source2, source1])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -98,7 +98,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, sources: [source1, source2])
         let framework2 = makeFramework(project: project2, sources: [source3, source4])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -126,7 +126,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, sources: [source1, source2])
         let framework2 = makeFramework(project: project2, sources: [source3, source4])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -156,7 +156,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, sources: [source1, source2])
         let framework2 = makeFramework(project: project2, sources: [source3, source4])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -188,7 +188,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, resources: [resourceFile1])
         let framework2 = makeFramework(project: project2, resources: [resourceFile2])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -216,7 +216,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, resources: [resourceFolderReference1])
         let framework2 = makeFramework(project: project2, resources: [resourceFolderReference2])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -245,7 +245,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, resources: resources)
         let framework2 = makeFramework(project: project2, resources: resources)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -275,7 +275,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, coreDataModels: [coreDataModel1])
         let framework2 = makeFramework(project: project2, coreDataModels: [coreDataModel2])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -303,7 +303,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, coreDataModels: [coreDataModel1])
         let framework2 = makeFramework(project: project2, coreDataModels: [coreDataModel1])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -335,7 +335,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, platform: .iOS)
         let framework2 = makeFramework(project: project2, platform: .macOS)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -364,7 +364,7 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         let project2 = Project.test(path: try temporaryPath().appending(component: "f2"))
         let framework1 = makeFramework(project: project1, productName: "1")
         let framework2 = makeFramework(project: project2, productName: "2")
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 project1.path: project1,
                 project2.path: project2,
@@ -422,8 +422,8 @@ final class ContentHashingIntegrationTests: TuistTestCase {
         resources: [ResourceFileElement] = [],
         coreDataModels: [CoreDataModel] = [],
         targetActions: [TargetAction] = []
-    ) -> ValueGraphTarget {
-        ValueGraphTarget.test(
+    ) -> GraphTarget {
+        GraphTarget.test(
             path: project.path,
             target: .test(
                 platform: platform,

Tests/TuistCacheTests/Cache/CacheGraphMutatorTests.swift

@@ -44,25 +44,25 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
         // Given: D
         let dFramework = Target.test(name: "D", platform: .iOS, product: .framework)
         let dProject = Project.test(path: path.appending(component: "D"), name: "D", targets: [dFramework])
-        let dFrameworkGraphTarget = ValueGraphTarget.test(path: dProject.path, target: dFramework, project: dProject)
+        let dFrameworkGraphTarget = GraphTarget.test(path: dProject.path, target: dFramework, project: dProject)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bFrameworkGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bFrameworkGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
         let cProject = Project.test(path: path.appending(component: "C"), name: "C", targets: [cFramework])
-        let cFrameworkGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cFrameworkGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let app = Target.test(name: "App", platform: .iOS, product: .app)
         let appProject = Project.test(path: path.appending(component: "App"), name: "App", targets: [app])
-        let appTargetGraphTarget = ValueGraphTarget.test(path: appProject.path, target: app, project: appProject)
+        let appTargetGraphTarget = GraphTarget.test(path: appProject.path, target: app, project: appProject)
 
         let graphTargets = [bFrameworkGraphTarget, cFrameworkGraphTarget, dFrameworkGraphTarget, appTargetGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -81,11 +81,11 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let dXCFrameworkPath = path.appending(component: "D.xcframework")
-        let dXCFramework = ValueGraphDependency.testXCFramework(path: dXCFrameworkPath)
+        let dXCFramework = GraphDependency.testXCFramework(path: dXCFrameworkPath)
         let bXCFrameworkPath = path.appending(component: "B.xcframework")
-        let bXCFramework = ValueGraphDependency.testXCFramework(path: bXCFrameworkPath)
+        let bXCFramework = GraphDependency.testXCFramework(path: bXCFrameworkPath)
         let cXCFrameworkPath = path.appending(component: "C.xcframework")
-        let cXCFramework = ValueGraphDependency.testXCFramework(path: cXCFrameworkPath)
+        let cXCFramework = GraphDependency.testXCFramework(path: cXCFrameworkPath)
         let xcframeworks = [
             dFrameworkGraphTarget: dXCFrameworkPath,
             bFrameworkGraphTarget: bXCFrameworkPath,
@@ -103,7 +103,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find .framework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -141,25 +141,25 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given: D
         let dFrameworkPath = path.appending(component: "D.framework")
-        let dFramework = ValueGraphDependency.testFramework(path: dFrameworkPath)
+        let dFramework = GraphDependency.testFramework(path: dFrameworkPath)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
         let cProject = Project.test(path: path.appending(component: "C"), name: "C", targets: [cFramework])
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let appTarget = Target.test(name: "App", platform: .iOS, product: .app)
         let appProject = Project.test(path: path.appending(component: "App"), name: "App", targets: [appTarget])
-        let appGraphTarget = ValueGraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
+        let appGraphTarget = GraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
 
         let graphTargets = [bGraphTarget, cGraphTarget, appGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -178,9 +178,9 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let bXCFrameworkPath = path.appending(component: "B.xcframework")
-        let bXCFramework = ValueGraphDependency.testXCFramework(path: bXCFrameworkPath)
+        let bXCFramework = GraphDependency.testXCFramework(path: bXCFrameworkPath)
         let cXCFrameworkPath = path.appending(component: "C.xcframework")
-        let cXCFramework = ValueGraphDependency.testXCFramework(path: cXCFrameworkPath)
+        let cXCFramework = GraphDependency.testXCFramework(path: cXCFrameworkPath)
         let xcframeworks = [
             bGraphTarget: bXCFrameworkPath,
             cGraphTarget: cXCFrameworkPath,
@@ -197,7 +197,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find .framework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -237,29 +237,29 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given E
         let eXCFrameworkPath = path.appending(component: "E.xcframework")
-        let eXCFramework = ValueGraphDependency.testXCFramework(path: eXCFrameworkPath)
+        let eXCFramework = GraphDependency.testXCFramework(path: eXCFrameworkPath)
 
         // Given: D
         let dFrameworkPath = path.appending(component: "D.framework")
-        let dFramework = ValueGraphDependency.testFramework(path: dFrameworkPath)
+        let dFramework = GraphDependency.testFramework(path: dFrameworkPath)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
         let cProject = Project.test(path: path.appending(component: "C"), name: "C", targets: [cFramework])
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let appTarget = Target.test(name: "App", platform: .iOS, product: .app)
         let appProject = Project.test(path: path.appending(component: "App"), name: "App", targets: [appTarget])
-        let appGraphTarget = ValueGraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
+        let appGraphTarget = GraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
 
         let graphTargets = [bGraphTarget, cGraphTarget, appGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -279,9 +279,9 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let bXCFrameworkPath = path.appending(component: "B.xcframework")
-        let bXCFramework = ValueGraphDependency.testXCFramework(path: bXCFrameworkPath)
+        let bXCFramework = GraphDependency.testXCFramework(path: bXCFrameworkPath)
         let cXCFrameworkPath = path.appending(component: "C.xcframework")
-        let cXCFramework = ValueGraphDependency.testXCFramework(path: cXCFrameworkPath)
+        let cXCFramework = GraphDependency.testXCFramework(path: cXCFrameworkPath)
         let xcframeworks = [
             bGraphTarget: bXCFrameworkPath,
             cGraphTarget: cXCFrameworkPath,
@@ -298,7 +298,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find .framework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -339,32 +339,32 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given: E
         let eXCFrameworkPath = path.appending(component: "E.xcframework")
-        let eXCFramework = ValueGraphDependency.testXCFramework(path: eXCFrameworkPath)
+        let eXCFramework = GraphDependency.testXCFramework(path: eXCFrameworkPath)
 
         // Given: D
         let dFrameworkPath = path.appending(component: "D.framework")
-        let dFramework = ValueGraphDependency.testFramework(path: dFrameworkPath)
+        let dFramework = GraphDependency.testFramework(path: dFrameworkPath)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cProject = Project.test(path: path.appending(component: "C"), name: "C")
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let appProject = Project.test(path: path.appending(component: "App"), name: "App")
-        let appTarget = ValueGraphTarget.test(
+        let appTarget = GraphTarget.test(
             path: appProject.path,
             target: Target.test(name: "App", platform: .iOS, product: .app),
             project: appProject
         )
 
         let graphTargets = [bGraphTarget, cGraphTarget, appTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -383,7 +383,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let cXCFrameworkPath = path.appending(component: "C.xcframework")
-        let cXCFramework = ValueGraphDependency.testXCFramework(path: cXCFrameworkPath)
+        let cXCFramework = GraphDependency.testXCFramework(path: cXCFrameworkPath)
         let xcframeworks = [
             cGraphTarget: cXCFrameworkPath,
         ]
@@ -398,7 +398,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find .framework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -435,23 +435,23 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
         // Given: C
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
         let cProject = Project.test(path: path.appending(component: "C"), name: "C", targets: [cFramework])
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: App
         let appProject = Project.test(path: path.appending(component: "App"), name: "App")
-        let appGraphTarget = ValueGraphTarget.test(
+        let appGraphTarget = GraphTarget.test(
             path: appProject.path,
             target: Target.test(name: "App", platform: .iOS, product: .app),
             project: appProject
         )
 
         let graphTargets = [bGraphTarget, cGraphTarget, appGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -491,25 +491,25 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
         // Given: D
         let dFramework = Target.test(name: "D", platform: .iOS, product: .framework)
         let dProject = Project.test(path: path.appending(component: "D"), name: "D", targets: [dFramework])
-        let dGraphTarget = ValueGraphTarget.test(path: dProject.path, target: dFramework, project: dProject)
+        let dGraphTarget = GraphTarget.test(path: dProject.path, target: dFramework, project: dProject)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
         let cProject = Project.test(path: path.appending(component: "C"), name: "C", targets: [cFramework])
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let appTarget = Target.test(name: "App", platform: .iOS, product: .app)
         let appProject = Project.test(path: path.appending(component: "App"), name: "App", targets: [appTarget])
-        let appGraphTarget = ValueGraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
+        let appGraphTarget = GraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
 
         let graphTargets = [bGraphTarget, cGraphTarget, dGraphTarget, appGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -528,11 +528,11 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let dCachedFrameworkPath = path.appending(component: "D.framework")
-        let dCachedFramework = ValueGraphDependency.testFramework(path: dCachedFrameworkPath)
+        let dCachedFramework = GraphDependency.testFramework(path: dCachedFrameworkPath)
         let bCachedFrameworkPath = path.appending(component: "B.framework")
-        let bCachedFramework = ValueGraphDependency.testFramework(path: bCachedFrameworkPath)
+        let bCachedFramework = GraphDependency.testFramework(path: bCachedFrameworkPath)
         let cCachedFrameworkPath = path.appending(component: "C.framework")
-        let cCachedFramework = ValueGraphDependency.testFramework(path: cCachedFrameworkPath)
+        let cCachedFramework = GraphDependency.testFramework(path: cCachedFrameworkPath)
         let frameworks = [
             dGraphTarget: dCachedFrameworkPath,
             bGraphTarget: bCachedFrameworkPath,
@@ -550,7 +550,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find an .xcframework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -588,25 +588,25 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given: D
         let dFrameworkPath = path.appending(component: "D.framework")
-        let dFramework = ValueGraphDependency.testFramework(path: dFrameworkPath)
+        let dFramework = GraphDependency.testFramework(path: dFrameworkPath)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
         let cProject = Project.test(path: path.appending(component: "C"), name: "C", targets: [cFramework])
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let appTarget = Target.test(name: "App", platform: .iOS, product: .app)
         let appProject = Project.test(path: path.appending(component: "App"), name: "App", targets: [appTarget])
-        let appGraphTarget = ValueGraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
+        let appGraphTarget = GraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
 
         let graphTargets = [bGraphTarget, cGraphTarget, appGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -625,9 +625,9 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let bCachedFrameworkPath = path.appending(component: "B.framework")
-        let bCachedFramework = ValueGraphDependency.testFramework(path: bCachedFrameworkPath)
+        let bCachedFramework = GraphDependency.testFramework(path: bCachedFrameworkPath)
         let cCachedFrameworkPath = path.appending(component: "C.framework")
-        let cCachedFramework = ValueGraphDependency.testFramework(path: cCachedFrameworkPath)
+        let cCachedFramework = GraphDependency.testFramework(path: cCachedFrameworkPath)
         let frameworks = [
             bGraphTarget: bCachedFrameworkPath,
             cGraphTarget: cCachedFrameworkPath,
@@ -644,7 +644,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find .framework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -684,29 +684,29 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given E
         let eXCFrameworkPath = path.appending(component: "E.xcframework")
-        let eXCFramework = ValueGraphDependency.testXCFramework(path: eXCFrameworkPath)
+        let eXCFramework = GraphDependency.testXCFramework(path: eXCFrameworkPath)
 
         // Given: D
         let dFrameworkPath = path.appending(component: "D.framework")
-        let dFramework = ValueGraphDependency.testFramework(path: dFrameworkPath)
+        let dFramework = GraphDependency.testFramework(path: dFrameworkPath)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
         let cProject = Project.test(path: path.appending(component: "C"), name: "C", targets: [cFramework])
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let appTarget = Target.test(name: "App", platform: .iOS, product: .app)
         let appProject = Project.test(path: path.appending(component: "App"), name: "App", targets: [appTarget])
-        let appGraphTarget = ValueGraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
+        let appGraphTarget = GraphTarget.test(path: appProject.path, target: appTarget, project: appProject)
 
         let graphTargets = [bGraphTarget, cGraphTarget, appGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -726,9 +726,9 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let bCachedFrameworkPath = path.appending(component: "B.framework")
-        let bCachedFramework = ValueGraphDependency.testFramework(path: bCachedFrameworkPath)
+        let bCachedFramework = GraphDependency.testFramework(path: bCachedFrameworkPath)
         let cCachedFrameworkPath = path.appending(component: "C.framework")
-        let cCachedFramework = ValueGraphDependency.testFramework(path: cCachedFrameworkPath)
+        let cCachedFramework = GraphDependency.testFramework(path: cCachedFrameworkPath)
         let frameworks = [
             bGraphTarget: bCachedFrameworkPath,
             cGraphTarget: cCachedFrameworkPath,
@@ -746,7 +746,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find an .xcframework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -787,28 +787,28 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given: E
         let eXCFrameworkPath = path.appending(component: "E.xcframework")
-        let eXCFramework = ValueGraphDependency.testXCFramework(path: eXCFrameworkPath)
+        let eXCFramework = GraphDependency.testXCFramework(path: eXCFrameworkPath)
 
         // Given: D
         let dFrameworkPath = path.appending(component: "D.framework")
-        let dFramework = ValueGraphDependency.testFramework(path: dFrameworkPath)
+        let dFramework = GraphDependency.testFramework(path: dFrameworkPath)
 
         // Given: B
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
         let bProject = Project.test(path: path.appending(component: "B"), name: "B", targets: [bFramework])
-        let bGraphTarget = ValueGraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
+        let bGraphTarget = GraphTarget.test(path: bProject.path, target: bFramework, project: bProject)
 
         // Given: C
         let cProject = Project.test(path: path.appending(component: "C"), name: "C")
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
-        let cGraphTarget = ValueGraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
+        let cGraphTarget = GraphTarget.test(path: cProject.path, target: cFramework, project: cProject)
 
         // Given: App
         let appProject = Project.test(path: path.appending(component: "App"), name: "App")
-        let appGraphTarget = ValueGraphTarget.test(path: appProject.path, target: Target.test(name: "App", platform: .iOS, product: .app), project: appProject)
+        let appGraphTarget = GraphTarget.test(path: appProject.path, target: Target.test(name: "App", platform: .iOS, product: .app), project: appProject)
 
         let graphTargets = [bGraphTarget, cGraphTarget, appGraphTarget]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -827,7 +827,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
 
         // Given xcframeworks
         let cCachedFrameworkPath = path.appending(component: "C.xcframework")
-        let cCachedFramework = ValueGraphDependency.testFramework(path: cCachedFrameworkPath)
+        let cCachedFramework = GraphDependency.testFramework(path: cCachedFrameworkPath)
         let frameworks = [
             cGraphTarget: cCachedFrameworkPath,
         ]
@@ -841,7 +841,7 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             throw "Can't find an .xcframework here"
         }
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             projects: graphProjects(graphTargets),
             targets: self.graphTargets(graphTargets),
             dependencies: [
@@ -866,20 +866,20 @@ final class CacheGraphMutatorTests: TuistUnitTestCase {
             got,
             expectedGraph
         )
-//        let app = try XCTUnwrap(got.entryNodes.first as? ValueGraphTarget)
-//        let b = try XCTUnwrap(app.dependencies.compactMap { $0 as? ValueGraphTarget }.first(where: { $0.name == "B" }))
+//        let app = try XCTUnwrap(got.entryNodes.first as? GraphTarget)
+//        let b = try XCTUnwrap(app.dependencies.compactMap { $0 as? GraphTarget }.first(where: { $0.name == "B" }))
 //        let c = try XCTUnwrap(app.dependencies.compactMap { $0 as? GraphTarget }.first(where: { $0.path == cCachedFrameworkPath }))
 //        XCTAssertTrue(b.dependencies.contains(where: { $0.path == dFrameworkPath }))
 //        XCTAssertTrue(c.dependencies.contains(where: { $0.path == eXCFrameworkPath }))
     }
 
-    fileprivate func graphProjects(_ targets: [ValueGraphTarget]) -> [AbsolutePath: Project] {
+    fileprivate func graphProjects(_ targets: [GraphTarget]) -> [AbsolutePath: Project] {
         targets.reduce(into: [AbsolutePath: Project]()) { acc, target in
             acc[target.project.path] = target.project
         }
     }
 
-    fileprivate func graphTargets(_ targets: [ValueGraphTarget]) -> [AbsolutePath: [String: Target]] {
+    fileprivate func graphTargets(_ targets: [GraphTarget]) -> [AbsolutePath: [String: Target]] {
         targets.reduce(into: [AbsolutePath: [String: Target]]()) { acc, target in
             var targets = acc[target.path, default: [:]]
             targets[target.target.name] = target.target

Tests/TuistCacheTests/ContentHashing/GraphContentHasherTests.swift

@@ -23,7 +23,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
 
     func test_contentHashes_emptyGraph() throws {
         // Given
-        let graph = ValueGraph.test()
+        let graph = Graph.test()
 
         // When
         let hashes = try subject.contentHashes(for: graph)
@@ -38,7 +38,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
         let project: Project = .test(
             path: path
         )
-        let frameworkTarget = ValueGraphTarget.test(
+        let frameworkTarget = GraphTarget.test(
             path: path,
             target: .test(
                 name: "FrameworkA",
@@ -48,7 +48,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
             ),
             project: .test(path: path)
         )
-        let secondFrameworkTarget = ValueGraphTarget.test(
+        let secondFrameworkTarget = GraphTarget.test(
             path: path,
             target: .test(
                 name: "FrameworkB",
@@ -58,7 +58,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
             ),
             project: .test(path: path)
         )
-        let appTarget = ValueGraphTarget.test(
+        let appTarget = GraphTarget.test(
             path: path,
             target: .test(
                 name: "App",
@@ -68,7 +68,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
             ),
             project: .test(path: path)
         )
-        let dynamicLibraryTarget = ValueGraphTarget.test(
+        let dynamicLibraryTarget = GraphTarget.test(
             path: path,
             target: .test(
                 name: "DynamicLibrary",
@@ -78,7 +78,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
             ),
             project: .test(path: path)
         )
-        let staticFrameworkTarget = ValueGraphTarget.test(
+        let staticFrameworkTarget = GraphTarget.test(
             path: path,
             target: .test(
                 name: "StaticFramework",
@@ -89,7 +89,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
             project: .test(path: path)
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [project.path: project],
             targets: [
@@ -112,7 +112,7 @@ final class GraphContentHasherTests: TuistUnitTestCase {
                 $0.target.product == .framework
             }
         )
-        let hashedTargets: [ValueGraphTarget] = hashes.keys.sorted { left, right -> Bool in
+        let hashedTargets: [GraphTarget] = hashes.keys.sorted { left, right -> Bool in
             left.path.pathString < right.path.pathString
         }
         .sorted(by: { $0.target.name < $1.target.name })

Tests/TuistCacheTests/GraphMappers/CacheMapperTests.swift

@@ -51,20 +51,20 @@ final class CacheMapperTests: TuistUnitTestCase {
 
         // Given
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
-        let cGraphTarget = ValueGraphTarget.test(path: path, target: cFramework)
+        let cGraphTarget = GraphTarget.test(path: path, target: cFramework)
         let cXCFrameworkPath = path.appending(component: "C.xcframework")
         let cHash = "C"
 
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
-        let bGraphTarget = ValueGraphTarget.test(path: path, target: bFramework)
+        let bGraphTarget = GraphTarget.test(path: path, target: bFramework)
         let bHash = "B"
         let bXCFrameworkPath = path.appending(component: "B.xcframework")
 
         let app = Target.test(name: "App", platform: .iOS, product: .app)
-        let appGraphTarget = ValueGraphTarget.test(path: path, target: app)
+        let appGraphTarget = GraphTarget.test(path: path, target: app)
         let appHash = "App"
 
-        let inputGraph = ValueGraph.test(
+        let inputGraph = Graph.test(
             name: "input",
             projects: [path: project],
             dependencies: [
@@ -76,7 +76,7 @@ final class CacheMapperTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let outputGraph = ValueGraph.test(
+        let outputGraph = Graph.test(
             name: "output",
             projects: inputGraph.projects,
             dependencies: inputGraph.dependencies
@@ -120,19 +120,19 @@ final class CacheMapperTests: TuistUnitTestCase {
 
         // Given
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
-        let cGraphTarget = ValueGraphTarget.test(path: path, target: cFramework)
+        let cGraphTarget = GraphTarget.test(path: path, target: cFramework)
         let cHash = "C"
 
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
-        let bGraphTarget = ValueGraphTarget.test(path: path, target: bFramework)
+        let bGraphTarget = GraphTarget.test(path: path, target: bFramework)
         let bHash = "B"
         let bXCFrameworkPath = path.appending(component: "B.xcframework")
 
         let app = Target.test(name: "App", platform: .iOS, product: .app)
-        let appGraphTarget = ValueGraphTarget.test(path: path, target: app)
+        let appGraphTarget = GraphTarget.test(path: path, target: app)
         let appHash = "App"
 
-        let inputGraph = ValueGraph.test(
+        let inputGraph = Graph.test(
             name: "input",
             projects: [path: project],
             dependencies: [
@@ -144,7 +144,7 @@ final class CacheMapperTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let outputGraph = ValueGraph.test(
+        let outputGraph = Graph.test(
             name: "output",
             projects: inputGraph.projects,
             dependencies: inputGraph.dependencies
@@ -194,15 +194,15 @@ final class CacheMapperTests: TuistUnitTestCase {
         )
 
         let cFramework = Target.test(name: "C", platform: .iOS, product: .framework)
-        let cGraphTarget = ValueGraphTarget.test(path: path, target: cFramework)
+        let cGraphTarget = GraphTarget.test(path: path, target: cFramework)
 
         let bFramework = Target.test(name: "B", platform: .iOS, product: .framework)
-        let bGraphTarget = ValueGraphTarget.test(path: path, target: bFramework)
+        let bGraphTarget = GraphTarget.test(path: path, target: bFramework)
 
         let app = Target.test(name: "App", platform: .iOS, product: .app)
-        let appGraphTarget = ValueGraphTarget.test(path: path, target: app)
+        let appGraphTarget = GraphTarget.test(path: path, target: app)
 
-        let inputGraph = ValueGraph.test(
+        let inputGraph = Graph.test(
             name: "input",
             projects: [path: project],
             dependencies: [
@@ -214,7 +214,7 @@ final class CacheMapperTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let outputGraph = ValueGraph.test(
+        let outputGraph = Graph.test(
             name: "output",
             projects: inputGraph.projects,
             dependencies: inputGraph.dependencies

Tests/TuistCacheTests/GraphMappers/CacheTreeShakingGraphMapperTests.swift

@@ -25,13 +25,13 @@ final class CacheTreeShakingGraphMapperTests: TuistUnitTestCase {
         let target = Target.test(prune: true)
         let project = Project.test(targets: [target])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             projects: [project.path: project],
             targets: [project.path: [target.name: target]]
         )
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             path: project.path,
             projects: [:],
             targets: [:]
@@ -54,7 +54,7 @@ final class CacheTreeShakingGraphMapperTests: TuistUnitTestCase {
         let secondTarget = Target.test(name: "second", prune: true)
         let project = Project.test(targets: [firstTarget, secondTarget])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             projects: [project.path: project],
             targets: [project.path: [firstTarget.name: firstTarget, secondTarget.name: secondTarget]],
@@ -81,7 +81,7 @@ final class CacheTreeShakingGraphMapperTests: TuistUnitTestCase {
         ]
         let project = Project.test(path: path, targets: [target], schemes: schemes)
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             projects: [project.path: project],
             targets: [project.path: [target.name: target]],
@@ -115,7 +115,7 @@ final class CacheTreeShakingGraphMapperTests: TuistUnitTestCase {
         )
 
         // Given
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             workspace: workspace,
             projects: [project.path: project],
@@ -145,7 +145,7 @@ final class CacheTreeShakingGraphMapperTests: TuistUnitTestCase {
             schemes: schemes
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             workspace: workspace,
             projects: [project.path: project],
@@ -178,7 +178,7 @@ final class CacheTreeShakingGraphMapperTests: TuistUnitTestCase {
             )
         )
         let project = Project.test(path: path, targets: targets, schemes: [scheme])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             projects: [project.path: project],
             targets: [project.path: Dictionary(uniqueKeysWithValues: targets.map { ($0.name, $0) })]
@@ -195,7 +195,7 @@ final class CacheTreeShakingGraphMapperTests: TuistUnitTestCase {
             )
         )
         let expectedProject = Project.test(path: path, targets: unprunedTargets, schemes: [schemeWithUnprunedTargets])
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             path: expectedProject.path,
             projects: [expectedProject.path: expectedProject],
             targets: [expectedProject.path: Dictionary(uniqueKeysWithValues: unprunedTargets.map { ($0.name, $0) })]

Tests/TuistCacheTests/GraphMappers/Mocks/MockCacheGraphMutator.swift

@@ -10,12 +10,12 @@ import XCTest
 final class MockCacheGraphMutator: CacheGraphMutating {
     var invokedMap = false
     var invokedMapCount = 0
-    var invokedMapParameters: (graph: ValueGraph, precompiledFrameworks: [ValueGraphTarget: AbsolutePath], sources: Set<String>)?
-    var invokedMapParametersList = [(graph: ValueGraph, precompiledFrameworks: [ValueGraphTarget: AbsolutePath], sources: Set<String>)]()
+    var invokedMapParameters: (graph: Graph, precompiledFrameworks: [GraphTarget: AbsolutePath], sources: Set<String>)?
+    var invokedMapParametersList = [(graph: Graph, precompiledFrameworks: [GraphTarget: AbsolutePath], sources: Set<String>)]()
     var stubbedMapError: Error?
-    var stubbedMapResult: ValueGraph!
+    var stubbedMapResult: Graph!
 
-    func map(graph: ValueGraph, precompiledFrameworks: [ValueGraphTarget: AbsolutePath], sources: Set<String>) throws -> ValueGraph {
+    func map(graph: Graph, precompiledFrameworks: [GraphTarget: AbsolutePath], sources: Set<String>) throws -> Graph {
         invokedMap = true
         invokedMapCount += 1
         invokedMapParameters = (graph, precompiledFrameworks, sources)

Tests/TuistCacheTests/GraphMappers/Mocks/MockCacheTreeShakingGraphMapper.swift

@@ -8,12 +8,12 @@ public final class MockCacheTreeShakingGraphMapper: GraphMapping {
 
     var invokedMapGraph = false
     var invokedMapGraphCount = 0
-    var invokedMapGraphParameters: (graph: ValueGraph, Void)?
-    var invokedMapGraphParametersList = [(graph: ValueGraph, Void)]()
+    var invokedMapGraphParameters: (graph: Graph, Void)?
+    var invokedMapGraphParametersList = [(graph: Graph, Void)]()
     var stubbedMapGraphError: Error?
-    var stubbedMapGraphResult: (ValueGraph, [SideEffectDescriptor])!
+    var stubbedMapGraphResult: (Graph, [SideEffectDescriptor])!
 
-    public func map(graph: ValueGraph) throws -> (ValueGraph, [SideEffectDescriptor]) {
+    public func map(graph: Graph) throws -> (Graph, [SideEffectDescriptor]) {
         invokedMapGraph = true
         invokedMapGraphCount += 1
         invokedMapGraphParameters = (graph, ())

Tests/TuistCacheTests/GraphMappers/TestsCacheGraphMapperTests.swift

@@ -43,14 +43,14 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
     // SchemeB: UnitTestsA -> FrameworkA, UnitTestsB (UnitTestsB cached)
     func test_map_all_cached() throws {
         let project = Project.test()
-        let frameworkA = ValueGraphTarget.test(
+        let frameworkA = GraphTarget.test(
             path: project.path,
             target: Target.test(
                 name: "FrameworkA"
             ),
             project: project
         )
-        let unitTestsA = ValueGraphTarget.test(
+        let unitTestsA = GraphTarget.test(
             path: project.path,
             target: Target.test(
                 name: "UnitTestsA",
@@ -60,7 +60,7 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
             ),
             project: project
         )
-        let unitTestsB = ValueGraphTarget.test(
+        let unitTestsB = GraphTarget.test(
             path: project.path,
             target: Target.test(
                 name: "UnitTestsB"
@@ -125,7 +125,7 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
             ]
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             workspace: workspace,
             projects: [project.path: project],
             targets: [
@@ -146,7 +146,7 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
         )
 
         graphContentHasher.contentHashesStub = { graph, _, _ in
-            ValueGraphTraverser(graph: graph).allTargets().reduce(into: [:]) { acc, target in
+            GraphTraverser(graph: graph).allTargets().reduce(into: [:]) { acc, target in
                 acc[target] = target.target.name
             }
         }
@@ -158,7 +158,7 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
             cacheDirectoriesProvider.testsCacheDirectory.appending(component: "UnitTestsA")
         )
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             workspace: Workspace.test(
                 schemes: [
                     Scheme.test(
@@ -251,14 +251,14 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
     // SchemeA: UnitTestsA -> FrameworkA (only UnitTestsA cached)
     func test_map_only_tests_cached() throws {
         let project = Project.test()
-        let frameworkA = ValueGraphTarget.test(
+        let frameworkA = GraphTarget.test(
             path: project.path,
             target: Target.test(
                 name: "FrameworkA"
             ),
             project: project
         )
-        let unitTestsA = ValueGraphTarget.test(
+        let unitTestsA = GraphTarget.test(
             path: project.path,
             target: Target.test(
                 name: "UnitTestsA",
@@ -297,7 +297,7 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
             ]
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             workspace: workspace,
             projects: [project.path: project],
             targets: [
@@ -314,7 +314,7 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
         )
 
         graphContentHasher.contentHashesStub = { graph, _, _ in
-            ValueGraphTraverser(graph: graph).allTargets().reduce(into: [:]) { acc, target in
+            GraphTraverser(graph: graph).allTargets().reduce(into: [:]) { acc, target in
                 acc[target] = target.target.name
             }
         }
@@ -323,7 +323,7 @@ final class TestsCacheMapperTests: TuistUnitTestCase {
             hashesCacheDirectory.appending(component: "UnitTestsA")
         )
 
-        let expectedGraph = ValueGraph.test(
+        let expectedGraph = Graph.test(
             workspace: Workspace.test(
                 schemes: [
                     Scheme.test(

Tests/TuistCacheTests/Linters/CacheGraphLinterTests.swift

@@ -20,12 +20,12 @@ final class CacheGraphLinterTests: TuistUnitTestCase {
         let target = Target.test(actions: [
             .init(name: "test", order: .post, script: .embedded("echo 'Hello World'")),
         ])
-        let graphTarget = ValueGraphTarget.test(
+        let graphTarget = GraphTarget.test(
             path: project.path,
             target: target,
             project: project
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 graphTarget.path: [graphTarget.target.name: graphTarget.target],

Tests/TuistCoreTests/Graph/GraphDependencyTests.swift

@@ -0,0 +1,28 @@
+import Foundation
+import TSCBasic
+import TuistGraph
+import XCTest
+@testable import TuistCore
+@testable import TuistSupportTesting
+
+final class GraphDependencyTests: TuistUnitTestCase {
+    func test_isTarget() {
+        XCTAssertFalse(GraphDependency.testXCFramework().isTarget)
+        XCTAssertFalse(GraphDependency.testFramework().isTarget)
+        XCTAssertFalse(GraphDependency.testLibrary().isTarget)
+        XCTAssertFalse(GraphDependency.testPackageProduct().isTarget)
+        XCTAssertTrue(GraphDependency.testTarget().isTarget)
+        XCTAssertFalse(GraphDependency.testSDK().isTarget)
+        XCTAssertFalse(GraphDependency.testCocoapods().isTarget)
+    }
+
+    func test_isPrecompiled() {
+        XCTAssertTrue(GraphDependency.testXCFramework().isPrecompiled)
+        XCTAssertTrue(GraphDependency.testFramework().isPrecompiled)
+        XCTAssertTrue(GraphDependency.testLibrary().isPrecompiled)
+        XCTAssertFalse(GraphDependency.testPackageProduct().isPrecompiled)
+        XCTAssertFalse(GraphDependency.testTarget().isPrecompiled)
+        XCTAssertFalse(GraphDependency.testSDK().isPrecompiled)
+        XCTAssertFalse(GraphDependency.testCocoapods().isPrecompiled)
+    }
+}

Tests/TuistCoreTests/Graph/GraphLoaderTests.swift

@@ -8,7 +8,7 @@ import XCTest
 @testable import TuistCoreTesting
 @testable import TuistSupportTesting
 
-final class ValueGraphLoaderTests: TuistUnitTestCase {
+final class GraphLoaderTests: TuistUnitTestCase {
     private var stubbedFrameworks = [AbsolutePath: PrecompiledMetadata]()
     private var stubbedLibraries = [AbsolutePath: PrecompiledMetadata]()
     private var stubbedXCFrameworks = [AbsolutePath: XCFrameworkMetadata]()
@@ -240,7 +240,7 @@ final class ValueGraphLoaderTests: TuistUnitTestCase {
         ])
 
         // Then
-        let frameworkDependency: ValueGraphDependency = .framework(
+        let frameworkDependency: GraphDependency = .framework(
             path: "/Frameworks/F.framework",
             binaryPath: "/Frameworks/F.framework/F",
             dsymPath: nil,
@@ -678,8 +678,8 @@ final class ValueGraphLoaderTests: TuistUnitTestCase {
 
     // MARK: - Helpers
 
-    private func makeSubject() -> ValueGraphLoader {
-        ValueGraphLoader(
+    private func makeSubject() -> GraphLoader {
+        GraphLoader(
             frameworkMetadataProvider: frameworkMetadataProvider,
             libraryMetadataProvider: libraryMetadataProvider,
             xcframeworkMetadataProvider: xcframeworkMetadataProvider,

Tests/TuistCoreTests/Graph/GraphTargetTests.swift

@@ -0,0 +1,16 @@
+import Foundation
+import TSCBasic
+import TuistGraph
+import XCTest
+@testable import TuistCore
+@testable import TuistCoreTesting
+@testable import TuistSupportTesting
+
+final class GraphTargetTests: TuistUnitTestCase {
+    func test_comparable() {
+        XCTAssertTrue(GraphTarget.test(target: Target.test(name: "a")) < GraphTarget.test(target: Target.test(name: "b")))
+        XCTAssertFalse(GraphTarget.test(target: Target.test(name: "b")) < GraphTarget.test(target: Target.test(name: "a")))
+        XCTAssertTrue(GraphTarget.test(path: "/a", target: Target.test(name: "a")) < GraphTarget.test(path: "/b", target: Target.test(name: "a")))
+        XCTAssertFalse(GraphTarget.test(path: "/b", target: Target.test(name: "a")) < GraphTarget.test(path: "/a", target: Target.test(name: "a")))
+    }
+}

Tests/TuistCoreTests/Graph/Mappers/GraphMapperTests.swift

@@ -10,8 +10,8 @@ import XCTest
 final class AnyGraphMapperTests: TuistUnitTestCase {
     func test_map() throws {
         // Given
-        let input = ValueGraph.test(name: "input")
-        let output = ValueGraph.test(name: "output")
+        let input = Graph.test(name: "input")
+        let output = Graph.test(name: "output")
         let subject = AnyGraphMapper(mapper: { graph in
             XCTAssertEqual(graph.name, input.name)
             return (output, [])
@@ -29,15 +29,15 @@ final class SequentialGraphMapperTests: TuistUnitTestCase {
     func test_map() throws {
         // Given
         let firstSideEffect = SideEffectDescriptor.file(.init(path: "/first"))
-        let input = ValueGraph.test(name: "0")
+        let input = Graph.test(name: "0")
         let first = AnyGraphMapper(mapper: { graph in
             XCTAssertEqual(graph.name, "0")
-            return (ValueGraph.test(name: "1"), [firstSideEffect])
+            return (Graph.test(name: "1"), [firstSideEffect])
         })
         let secondSideEffect = SideEffectDescriptor.file(.init(path: "/second"))
         let second = AnyGraphMapper(mapper: { graph in
             XCTAssertEqual(graph.name, "1")
-            return (ValueGraph.test(name: "2"), [secondSideEffect])
+            return (Graph.test(name: "2"), [secondSideEffect])
         })
         let subject = SequentialGraphMapper([first, second])
 

Tests/TuistCoreTests/ValueGraph/ValueGraphDependencyTests.swift

@@ -1,28 +0,0 @@
-import Foundation
-import TSCBasic
-import TuistGraph
-import XCTest
-@testable import TuistCore
-@testable import TuistSupportTesting
-
-final class ValueGraphDependencyTests: TuistUnitTestCase {
-    func test_isTarget() {
-        XCTAssertFalse(ValueGraphDependency.testXCFramework().isTarget)
-        XCTAssertFalse(ValueGraphDependency.testFramework().isTarget)
-        XCTAssertFalse(ValueGraphDependency.testLibrary().isTarget)
-        XCTAssertFalse(ValueGraphDependency.testPackageProduct().isTarget)
-        XCTAssertTrue(ValueGraphDependency.testTarget().isTarget)
-        XCTAssertFalse(ValueGraphDependency.testSDK().isTarget)
-        XCTAssertFalse(ValueGraphDependency.testCocoapods().isTarget)
-    }
-
-    func test_isPrecompiled() {
-        XCTAssertTrue(ValueGraphDependency.testXCFramework().isPrecompiled)
-        XCTAssertTrue(ValueGraphDependency.testFramework().isPrecompiled)
-        XCTAssertTrue(ValueGraphDependency.testLibrary().isPrecompiled)
-        XCTAssertFalse(ValueGraphDependency.testPackageProduct().isPrecompiled)
-        XCTAssertFalse(ValueGraphDependency.testTarget().isPrecompiled)
-        XCTAssertFalse(ValueGraphDependency.testSDK().isPrecompiled)
-        XCTAssertFalse(ValueGraphDependency.testCocoapods().isPrecompiled)
-    }
-}

Tests/TuistCoreTests/ValueGraph/ValueGraphTargetTests.swift

@@ -1,16 +0,0 @@
-import Foundation
-import TSCBasic
-import TuistGraph
-import XCTest
-@testable import TuistCore
-@testable import TuistCoreTesting
-@testable import TuistSupportTesting
-
-final class ValueGraphTargetTests: TuistUnitTestCase {
-    func test_comparable() {
-        XCTAssertTrue(ValueGraphTarget.test(target: Target.test(name: "a")) < ValueGraphTarget.test(target: Target.test(name: "b")))
-        XCTAssertFalse(ValueGraphTarget.test(target: Target.test(name: "b")) < ValueGraphTarget.test(target: Target.test(name: "a")))
-        XCTAssertTrue(ValueGraphTarget.test(path: "/a", target: Target.test(name: "a")) < ValueGraphTarget.test(path: "/b", target: Target.test(name: "a")))
-        XCTAssertFalse(ValueGraphTarget.test(path: "/b", target: Target.test(name: "a")) < ValueGraphTarget.test(path: "/a", target: Target.test(name: "a")))
-    }
-}

Tests/TuistGeneratorIntegrationTests/Generator/SwiftPackageManagerInteractorTests.swift

@@ -38,12 +38,12 @@ final class SwiftPackageManagerInteractorTests: TuistUnitTestCase {
             targets: [target],
             packages: [package]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             packages: [project.path: ["Test": package]],
-            dependencies: [ValueGraphDependency.packageProduct(path: project.path, product: "Test"): Set()]
+            dependencies: [GraphDependency.packageProduct(path: project.path, product: "Test"): Set()]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         let workspacePath = temporaryPath.appending(component: "\(project.name).xcworkspace")
         system.succeedCommand(["xcodebuild", "-resolvePackageDependencies", "-workspace", workspacePath.pathString, "-list"])
@@ -72,12 +72,12 @@ final class SwiftPackageManagerInteractorTests: TuistUnitTestCase {
             targets: [target],
             packages: [package]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             packages: [project.path: ["Test": package]],
-            dependencies: [ValueGraphDependency.packageProduct(path: project.path, product: "Test"): Set()]
+            dependencies: [GraphDependency.packageProduct(path: project.path, product: "Test"): Set()]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         let workspacePath = temporaryPath.appending(component: "\(project.name).xcworkspace")
         system.succeedCommand(["xcodebuild", "-resolvePackageDependencies", "-scmProvider", "system", "-workspace", workspacePath.pathString, "-list"])
@@ -106,12 +106,12 @@ final class SwiftPackageManagerInteractorTests: TuistUnitTestCase {
                 package,
             ]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             packages: [project.path: ["Test": package]],
-            dependencies: [ValueGraphDependency.packageProduct(path: project.path, product: "Test"): Set()]
+            dependencies: [GraphDependency.packageProduct(path: project.path, product: "Test"): Set()]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         let workspace = Workspace.test(
             name: project.name,
@@ -149,8 +149,8 @@ final class SwiftPackageManagerInteractorTests: TuistUnitTestCase {
             settings: .default,
             targets: [target]
         )
-        let graph = ValueGraph.test()
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test()
+        let graphTraverser = GraphTraverser(graph: graph)
 
         let workspace = Workspace.test(projects: [project.path])
         let workspacePath = temporaryPath.appending(component: workspace.name + ".xcworkspace")

Tests/TuistGeneratorIntegrationTests/Generator/WorkspaceGeneratorIntegrationTests.swift

@@ -38,14 +38,14 @@ final class WorkspaceGeneratorIntegrationTests: TuistTestCase {
                 targets: [Target.test(name: "Project\(index)_Target")]
             )
         }
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             workspace: Workspace.test(
                 path: temporaryPath,
                 projects: projects.map(\.key)
             ),
             projects: projects
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When / Then
         try (0 ..< 50).forEach { _ in

Tests/TuistGeneratorTests/Generator/BuildPhaseGeneratorTests.swift

@@ -244,8 +244,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
             headers: headers
         )
 
-        let graph = ValueGraph.test(path: tmpDir)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: tmpDir)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         try subject.generateBuildPhases(
             path: tmpDir,
@@ -283,8 +283,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
             sources: [SourceFile(path: "/test/file.swift", compilerFlags: nil)],
             headers: headers
         )
-        let graph = ValueGraph.test(path: tmpDir)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: tmpDir)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         try subject.generateBuildPhases(
             path: tmpDir,
@@ -321,8 +321,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
 
         let nativeTarget = PBXNativeTarget(name: "Test")
         let pbxproj = PBXProj()
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateResourcesBuildPhase(
@@ -377,7 +377,7 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
         try subject.generateResourcesBuildPhase(
             path: "/path",
             target: .test(resources: files.map { .file(path: $0) }),
-            graphTraverser: ValueGraphTraverser(graph: .test(path: path)),
+            graphTraverser: GraphTraverser(graph: .test(path: path)),
             pbxTarget: nativeTarget,
             fileElements: fileElements,
             pbxproj: pbxproj
@@ -442,8 +442,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
 
         let nativeTarget = PBXNativeTarget(name: "Test")
 
-        let graph = ValueGraph.test(path: temporaryPath)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: temporaryPath)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateResourcesBuildPhase(
@@ -481,8 +481,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
 
         let nativeTarget = PBXNativeTarget(name: "Test")
 
-        let graph = ValueGraph.test(path: temporaryPath)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: temporaryPath)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateResourcesBuildPhase(
@@ -524,19 +524,19 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
             bundle2.name: bundle2,
             app.name: app,
         ]]
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: bundle1.name, path: project.path): Set(),
             .target(name: bundle2.name, path: project.path): Set(),
             .target(name: app.name, path: project.path): Set([.target(name: bundle1.name, path: project.path),
                                                               .target(name: bundle2.name, path: project.path)]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [project.path: project],
             targets: targets,
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateResourcesBuildPhase(
@@ -573,17 +573,17 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
             projectA.path: [bundle.name: bundle],
             projectB.path: [app.name: app],
         ]
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: bundle.name, path: projectA.path): Set(),
             .target(name: app.name, path: projectB.path): Set([.target(name: bundle.name, path: projectA.path)]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [projectA.path: projectA, projectB.path: projectB],
             targets: targets,
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateResourcesBuildPhase(
@@ -667,7 +667,7 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
                 app.name: app,
             ],
         ]
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: appExtension.name, path: projectA.path): Set(),
             .target(name: stickerPackExtension.name, path: projectA.path): Set(),
             .target(name: app.name, path: projectA.path): Set([
@@ -675,13 +675,13 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
                 .target(name: stickerPackExtension.name, path: projectA.path),
             ]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [projectA.path: projectA],
             targets: targets,
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateAppExtensionsBuildPhase(
@@ -719,16 +719,16 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
         let targets: [AbsolutePath: [String: Target]] = [
             project.path: [app.name: app],
         ]
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: project.path): Set(),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             projects: [project.path: project],
             targets: targets,
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateAppExtensionsBuildPhase(
@@ -756,17 +756,17 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
         let targets: [AbsolutePath: [String: Target]] = [
             project.path: [app.name: app, watchApp.name: watchApp],
         ]
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: watchApp.name, path: project.path): Set(),
             .target(name: app.name, path: project.path): Set([.target(name: watchApp.name, path: project.path)]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             projects: [project.path: project],
             targets: targets,
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateEmbedWatchBuildPhase(
@@ -792,8 +792,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
         // Given
         system.swiftVersionStub = { "5.2" }
         let fileElements = ProjectFileElements([:])
-        let graph = ValueGraph.test()
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test()
+        let graphTraverser = GraphTraverser(graph: graph)
         let path = AbsolutePath("/test")
         let pbxproj = PBXProj()
         let pbxProject = createPbxProject(pbxproj: pbxproj)
@@ -870,17 +870,17 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
         let targets: [AbsolutePath: [String: Target]] = [
             project.path: [app.name: app, appClip.name: appClip],
         ]
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: appClip.name, path: project.path): Set(),
             .target(name: app.name, path: project.path): Set([.target(name: appClip.name, path: project.path)]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: project.path,
             projects: [project.path: project],
             targets: targets,
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         // When
         try subject.generateEmbedAppClipsBuildPhase(
             path: project.path,
@@ -914,8 +914,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
         )
         let target = Target.test(platform: .iOS, product: .staticFramework, coreDataModels: [coreDataModel])
         let fileElements = createFileElements(for: [coreDataModel])
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let pbxproj = PBXProj()
         let pbxTarget = PBXNativeTarget(name: target.name)
 
@@ -956,8 +956,8 @@ final class BuildPhaseGeneratorTests: TuistUnitTestCase {
         )
         let target = Target.test(platform: .iOS, product: .bundle, coreDataModels: [coreDataModel])
         let fileElements = createFileElements(for: [coreDataModel])
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let pbxproj = PBXProj()
         let pbxTarget = PBXNativeTarget(name: target.name)
 

Tests/TuistGeneratorTests/Generator/ConfigGeneratorTests.swift

@@ -113,8 +113,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         let target = Target.test(
             infoPlist: .file(path: sourceRootPath.appending(component: "Info.plist"))
         )
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -235,8 +235,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         // Given
         let project = Project.test()
         let target = Target.test(deploymentTarget: .iOS("12.0", [.iphone, .ipad]))
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -268,8 +268,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         // Given
         let project = Project.test()
         let target = Target.test(deploymentTarget: .macOS("10.14.1"))
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -300,8 +300,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         // Given
         let project = Project.test()
         let target = Target.test(deploymentTarget: .iOS("13.1", [.iphone, .ipad, .mac]))
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -335,8 +335,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         // Given
         let project = Project.test()
         let target = Target.test(deploymentTarget: .watchOS("6.0"))
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -367,8 +367,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         // Given
         let project = Project.test()
         let target = Target.test(deploymentTarget: .tvOS("14.0"))
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -443,8 +443,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         ])
         let project = Project.test()
         let target = Target.test()
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -471,8 +471,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         ])
         let project = Project.test()
         let target = Target.test()
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetConfig(
@@ -560,8 +560,8 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
             settings: .default,
             targets: [target]
         )
-        let graph = ValueGraph.test(path: project.path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: project.path)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         let fileElements = ProjectFileElements()
         let groups = ProjectGroups.generate(project: project, pbxproj: pbxproj)
@@ -600,14 +600,14 @@ final class ConfigGeneratorTests: TuistUnitTestCase {
         let target = Target.test(name: "Test", platform: platform, product: uiTest ? .uiTests : .unitTests)
         let project = Project.test(path: dir, name: "Project", targets: [target])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             name: project.name,
             path: project.path,
             projects: [project.path: project],
             targets: [project.path: [appTarget.name: appTarget, target.name: target]],
-            dependencies: [ValueGraphDependency.target(name: target.name, path: project.path): Set([.target(name: appTarget.name, path: project.path)])]
+            dependencies: [GraphDependency.target(name: target.name, path: project.path): Set([.target(name: appTarget.name, path: project.path)])]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         _ = try subject.generateTargetConfig(
             target,

Tests/TuistGeneratorTests/Generator/LinkGeneratorTests.swift

@@ -558,7 +558,7 @@ final class LinkGeneratorTests: XCTestCase {
         let path = AbsolutePath("/path/")
         let staticDependency = Target.test(name: "StaticDependency", product: .staticLibrary)
         let target = Target.test(name: "Static", product: .staticLibrary)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [path: .test(path: path)],
             targets: [
                 path: [
@@ -572,7 +572,7 @@ final class LinkGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let fileElements = createProjectFileElements(for: [staticDependency])
         let xcodeProjElements = createXcodeprojElements()
 
@@ -605,7 +605,7 @@ final class LinkGeneratorTests: XCTestCase {
         let path = AbsolutePath("/path/")
         let staticDependency = Target.test(name: "StaticDependency", product: .staticLibrary)
         let target = Target.test(name: "Dynamic", product: .framework)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [path: .test(path: path)],
             targets: [
                 path: [
@@ -619,7 +619,7 @@ final class LinkGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let fileElements = createProjectFileElements(for: [staticDependency])
         let xcodeProjElements = createXcodeprojElements()
 
@@ -647,7 +647,7 @@ final class LinkGeneratorTests: XCTestCase {
         let path = AbsolutePath("/path/")
         let resourceBundle = Target.test(name: "ResourceBundle", product: .bundle)
         let target = Target.test(name: "Target", product: .app)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [path: .test(path: path)],
             targets: [
                 path: [
@@ -663,7 +663,7 @@ final class LinkGeneratorTests: XCTestCase {
         )
         let fileElements = createProjectFileElements(for: [resourceBundle])
         let xcodeProjElements = createXcodeprojElements()
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateCopyProductsBuildPhase(

Tests/TuistGeneratorTests/Generator/ProjectDescriptorGeneratorTests.swift

@@ -45,14 +45,14 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
             targets: [app, test]
         )
 
-        let testGraphTarget = ValueGraphTarget(
+        let testGraphTarget = GraphTarget(
             path: project.path,
             target: test,
             project: project
         )
-        let appGraphTarget = ValueGraphTarget(path: project.path, target: app, project: project)
+        let appGraphTarget = GraphTarget(path: project.path, target: app, project: project)
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -66,7 +66,7 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let generatedProject = try subject.generate(project: project, graphTraverser: graphTraverser)
@@ -101,8 +101,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
         )
 
         let target = Target.test()
-        let graphTarget = ValueGraphTarget.test(path: project.path, target: target, project: project)
-        let graph = ValueGraph.test(
+        let graphTarget = GraphTarget.test(path: project.path, target: target, project: project)
+        let graph = Graph.test(
             projects: [project.path: project],
             packages: [
                 project.path: [
@@ -120,7 +120,7 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.generate(project: project, graphTraverser: graphTraverser)
@@ -141,10 +141,10 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
             name: "Project",
             targets: []
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.generate(project: project, graphTraverser: graphTraverser)
@@ -165,10 +165,10 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
             name: "Project",
             targets: []
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.generate(project: project, graphTraverser: graphTraverser)
@@ -182,8 +182,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
     func test_knownRegions() throws {
         // Given
         let path = try temporaryPath()
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let resources = [
             "resources/en.lproj/App.strings",
             "resources/en.lproj/Extension.strings",
@@ -216,8 +216,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
     func test_generate_setsDefaultKnownRegions() throws {
         // Given
         let path = try temporaryPath()
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let project = Project.test(
             path: path,
             targets: []
@@ -237,8 +237,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
     func test_generate_setsOrganizationName() throws {
         // Given
         let path = try temporaryPath()
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let project = Project.test(
             path: path,
             organizationName: "tuist",
@@ -259,8 +259,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
     func test_generate_setsResourcesTagsName() throws {
         // Given
         let path = try temporaryPath()
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let resources: [ResourceFileElement] = [.file(path: "/", tags: ["fileTag", "commonTag"]),
                                                 .folderReference(path: "/", tags: ["folderTag", "commonTag"])]
         let project = Project.test(
@@ -282,8 +282,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
     func test_generate_setsDefaultDevelopmentRegion() throws {
         // Given
         let path = try temporaryPath()
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let project = Project.test(
             path: path,
             targets: []
@@ -300,8 +300,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
     func test_generate_setsDevelopmentRegion() throws {
         // Given
         let path = try temporaryPath()
-        let graph = ValueGraph.test(path: path)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(path: path)
+        let graphTraverser = GraphTraverser(graph: graph)
         let project = Project.test(
             path: path,
             developmentRegion: "de",
@@ -329,8 +329,8 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
         )
 
         let target = Target.test()
-        let graphTarget = ValueGraphTarget(path: project.path, target: target, project: project)
-        let graph = ValueGraph.test(
+        let graphTarget = GraphTarget(path: project.path, target: target, project: project)
+        let graph = Graph.test(
             projects: [project.path: project],
             packages: [
                 project.path: [
@@ -348,7 +348,7 @@ final class ProjectDescriptorGeneratorTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.generate(project: project, graphTraverser: graphTraverser)

Tests/TuistGeneratorTests/Generator/ProjectFileElementsTests.swift

@@ -449,8 +449,8 @@ final class ProjectFileElementsTests: TuistUnitTestCase {
             .test(name: "Framework", product: .framework),
             .test(name: "Library", product: .staticLibrary),
         ])
-        let graph = ValueGraph.test()
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test()
+        let graphTraverser = GraphTraverser(graph: graph)
         let groups = ProjectGroups.generate(project: project, pbxproj: pbxproj)
 
         // When
@@ -488,8 +488,8 @@ final class ProjectFileElementsTests: TuistUnitTestCase {
                 xcodeProjPath: AbsolutePath.root.appending(component: "Project.xcodeproj"),
                 targets: targets
             )
-            let graph = ValueGraph.test()
-            let graphTraverser = ValueGraphTraverser(graph: graph)
+            let graph = Graph.test()
+            let graphTraverser = GraphTraverser(graph: graph)
             let groups = ProjectGroups.generate(project: project, pbxproj: pbxproj)
 
             // When
@@ -523,8 +523,8 @@ final class ProjectFileElementsTests: TuistUnitTestCase {
                 .test(name: "App", product: .app),
             ]
         )
-        let graph = ValueGraph.test()
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test()
+        let graphTraverser = GraphTraverser(graph: graph)
         let groups = ProjectGroups.generate(project: project, pbxproj: pbxproj)
 
         // When
@@ -802,13 +802,13 @@ final class ProjectFileElementsTests: TuistUnitTestCase {
             targets: [target],
             packages: [.remote(url: "url", requirement: .branch("master"))]
         )
-        let graphTarget: ValueGraphTarget = .test(path: project.path, target: target, project: project)
+        let graphTarget: GraphTarget = .test(path: project.path, target: target, project: project)
         let groups = ProjectGroups.generate(
             project: .test(path: .root, sourceRootPath: .root, xcodeProjPath: AbsolutePath.root.appending(component: "Project.xcodeproj")),
             pbxproj: pbxproj
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             packages: [
                 project.path: [
@@ -826,7 +826,7 @@ final class ProjectFileElementsTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateProjectFiles(

Tests/TuistGeneratorTests/Generator/SchemeDescriptorsGeneratorTests.swift

@@ -40,7 +40,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             path: projectPath,
             xcodeProjPath: xcodeProjPath
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -48,7 +48,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Then
         let got = try subject.schemeBuildAction(
@@ -89,7 +89,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             path: projectPath,
             xcodeProjPath: xcodeProjPath
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -97,7 +97,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeBuildAction(
@@ -150,7 +150,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             path: projectBPath,
             xcodeProjPath: xcodeProjBPath
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [
                 projectA.path: projectA,
                 projectB.path: projectB,
@@ -164,7 +164,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Then
         let got = try subject.schemeBuildAction(
@@ -219,7 +219,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             xcodeProjPath: xcodeProjPath,
             targets: [target]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -227,7 +227,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeBuildAction(
@@ -277,7 +277,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test(name: "AppTests", testAction: testAction)
         let generatedProjects = createGeneratedProjects(projects: [project])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -291,7 +291,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeTestAction(
@@ -331,7 +331,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test(name: "AppTests", testAction: testAction)
         let generatedProjects = createGeneratedProjects(projects: [project])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -345,7 +345,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeTestAction(
@@ -392,7 +392,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test(name: "AppTests", shared: true, buildAction: buildAction, testAction: testAction)
 
         let project = Project.test(path: projectPath, targets: [target, testTarget])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -406,7 +406,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeTestAction(
@@ -430,10 +430,10 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test()
         let project = Project.test()
         let generatedProject = GeneratedProject.test()
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Then
         let got = try subject.schemeTestAction(
@@ -458,10 +458,10 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let planList = [TestPlan(path: planPath, isDefault: true)]
         let scheme = Scheme.test(testAction: TestAction.test(testPlans: planList))
         let generatedProject = GeneratedProject.test()
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Then
         let got = try subject.schemeTestAction(
@@ -493,7 +493,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let buildAction = BuildAction.test(targets: [TargetReference(projectPath: project.path, name: "App")])
 
         let scheme = Scheme.test(name: "AppTests", shared: true, buildAction: buildAction, testAction: testAction)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -507,7 +507,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeTestAction(
@@ -537,7 +537,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test(name: "AppTests", testAction: testAction)
         let generatedProjects = createGeneratedProjects(projects: [project])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -552,7 +552,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             ]
         )
 
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeTestAction(
@@ -590,7 +590,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let project = Project.test(path: projectPath, targets: [testTarget])
 
         let generatedProjects = createGeneratedProjects(projects: [project])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -598,7 +598,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeTestAction(
@@ -669,7 +669,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             xcodeProjPath: projectPath.appending(component: "Project.xcodeproj"),
             targets: [app]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -677,7 +677,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeLaunchAction(
@@ -740,7 +740,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let app = Target.test(name: "App", product: .app)
 
         let project = Project.test(path: projectPath, targets: [app])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -748,7 +748,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeLaunchAction(
@@ -784,7 +784,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
 
         let scheme = Scheme.test(name: "Library", buildAction: buildAction, runAction: launchAction)
         let project = Project.test(path: projectPath, targets: [target])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -792,7 +792,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeLaunchAction(
@@ -827,7 +827,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             xcodeProjPath: projectPath.appending(component: "Project.xcodeproj"),
             targets: [target]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -835,7 +835,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeLaunchAction(
@@ -870,7 +870,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             xcodeProjPath: projectPath.appending(component: "Project.xcodeproj"),
             targets: [target]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -878,7 +878,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeProfileAction(
@@ -928,7 +928,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             xcodeProjPath: projectPath.appending(component: "Project.xcodeproj"),
             targets: [target]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -936,7 +936,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeProfileAction(
@@ -980,7 +980,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             xcodeProjPath: projectPath.appending(component: "Project.xcodeproj"),
             targets: [target]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -988,7 +988,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeProfileAction(
@@ -1042,7 +1042,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             xcodeProjPath: projectPath.appending(component: "Project.xcodeproj"),
             targets: [target]
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -1050,7 +1050,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeProfileAction(
@@ -1094,7 +1094,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test(buildAction: buildAction, analyzeAction: analyzeAction)
 
         let project = Project.test(path: projectPath, targets: [target])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -1102,7 +1102,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeAnalyzeAction(
@@ -1136,7 +1136,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test(buildAction: buildAction, archiveAction: archiveAction)
 
         let project = Project.test(path: projectPath, targets: [target])
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -1144,7 +1144,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = try subject.schemeArchiveAction(
@@ -1170,7 +1170,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
         let scheme = Scheme.test()
         let project = Project.test(targets: [app, framework, unitTests, uiTests], schemes: [scheme])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -1192,7 +1192,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = try subject.generateProjectSchemes(
@@ -1226,7 +1226,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             ]
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -1240,7 +1240,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = try subject.generateProjectSchemes(
@@ -1276,7 +1276,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
             ]
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [
@@ -1290,7 +1290,7 @@ final class SchemeDescriptorsGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = try subject.generateProjectSchemes(

Tests/TuistGeneratorTests/Generator/TargetGeneratorTests.swift

@@ -62,8 +62,8 @@ final class TargetGeneratorTests: XCTestCase {
             xcodeProjPath: path.appending(component: "Test.xcodeproj"),
             targets: [target]
         )
-        let graph = ValueGraph.test()
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test()
+        let graphTraverser = GraphTraverser(graph: graph)
         let groups = ProjectGroups.generate(
             project: project,
             pbxproj: pbxproj
@@ -113,7 +113,7 @@ final class TargetGeneratorTests: XCTestCase {
         let targetB = Target.test(name: "TargetB")
         let nativeTargetA = createNativeTarget(for: targetA)
         let nativeTargetB = createNativeTarget(for: targetB)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [path: .test(path: path)],
             targets: [
                 path: [
@@ -127,7 +127,7 @@ final class TargetGeneratorTests: XCTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         try subject.generateTargetDependencies(
@@ -148,8 +148,8 @@ final class TargetGeneratorTests: XCTestCase {
 
     func test_generateTarget_actions() throws {
         // Given
-        let graph = ValueGraph.test()
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test()
+        let graphTraverser = GraphTraverser(graph: graph)
         let target = Target.test(
             sources: [],
             resources: [],

Tests/TuistGeneratorTests/Generator/WorkspaceDescriptorGeneratorTests.swift

@@ -46,13 +46,13 @@ final class WorkspaceDescriptorGeneratorTests: TuistUnitTestCase {
             xcWorkspacePath: temporaryPath.appending(component: "Test.xcworkspace"),
             additionalFiles: additionalFiles
         )
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: temporaryPath,
             workspace: workspace
         )
 
         // When
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         let result = try subject.generate(graphTraverser: graphTraverser)
 
         // Then
@@ -72,11 +72,11 @@ final class WorkspaceDescriptorGeneratorTests: TuistUnitTestCase {
         let temporaryPath = try self.temporaryPath()
         try FileHandler.shared.createFolder(temporaryPath.appending(component: "\(name).xcworkspace"))
         let workspace = Workspace.test(name: name)
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: temporaryPath,
             workspace: workspace
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         XCTAssertNoThrow(
@@ -102,7 +102,7 @@ final class WorkspaceDescriptorGeneratorTests: TuistUnitTestCase {
             projects: [project.path]
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             workspace: workspace,
             projects: [project.path: project],
             targets: [
@@ -111,7 +111,7 @@ final class WorkspaceDescriptorGeneratorTests: TuistUnitTestCase {
                 ],
             ]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = try subject.generate(graphTraverser: graphTraverser)

Tests/TuistGeneratorTests/GraphViz/GraphToGraphVizMapperTests.swift

@@ -137,29 +137,29 @@ final class GraphToGraphVizMapperTests: XCTestCase {
         return graph
     }
 
-    private func makeGivenGraph() throws -> ValueGraph {
+    private func makeGivenGraph() throws -> TuistGraph.Graph {
         let project = Project.test(path: "/")
         let coreProject = Project.test(path: "/Core")
-        let framework = ValueGraphDependency.testFramework(path: AbsolutePath("/XcodeProj.framework"))
-        let library = ValueGraphDependency.testLibrary(path: AbsolutePath("/RxSwift.a"))
-        let sdk = ValueGraphDependency.testSDK(name: "CoreData.framework", status: .required, source: .developer)
+        let framework = GraphDependency.testFramework(path: AbsolutePath("/XcodeProj.framework"))
+        let library = GraphDependency.testLibrary(path: AbsolutePath("/RxSwift.a"))
+        let sdk = GraphDependency.testSDK(name: "CoreData.framework", status: .required, source: .developer)
 
-        let core = ValueGraphTarget.test(
+        let core = GraphTarget.test(
             path: coreProject.path,
             target: Target.test(name: "Core")
         )
-        let coreDependency = ValueGraphDependency.target(name: core.target.name, path: core.path)
-        let coreTests = ValueGraphTarget.test(
+        let coreDependency = GraphDependency.target(name: core.target.name, path: core.path)
+        let coreTests = GraphTarget.test(
             path: coreProject.path,
             target: Target.test(
                 name: "CoreTests",
                 product: .unitTests
             )
         )
-        let iOSApp = ValueGraphTarget.test(target: Target.test(name: "Tuist iOS"))
-        let watchApp = ValueGraphTarget.test(target: Target.test(name: "Tuist watchOS"))
+        let iOSApp = GraphTarget.test(target: Target.test(name: "Tuist iOS"))
+        let watchApp = GraphTarget.test(target: Target.test(name: "Tuist watchOS"))
 
-        let graph = ValueGraph.test(
+        let graph = TuistGraph.Graph.test(
             projects: [
                 project.path: project,
                 coreProject.path: coreProject,

Tests/TuistGeneratorTests/Linter/GraphLinterTests.swift

@@ -36,11 +36,11 @@ final class GraphLinterTests: TuistUnitTestCase {
         let frameworkAPath = temporaryPath.appending(RelativePath("Carthage/Build/iOS/A.framework"))
         let frameworkBPath = temporaryPath.appending(RelativePath("Carthage/Build/iOS/B.framework"))
         try FileHandler.shared.createFolder(frameworkAPath)
-        let graph = ValueGraph.test(dependencies: [
-            ValueGraphDependency.testFramework(path: frameworkAPath): Set(),
-            ValueGraphDependency.testFramework(path: frameworkBPath): Set(),
+        let graph = Graph.test(dependencies: [
+            GraphDependency.testFramework(path: frameworkAPath): Set(),
+            GraphDependency.testFramework(path: frameworkBPath): Set(),
         ])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -55,8 +55,8 @@ final class GraphLinterTests: TuistUnitTestCase {
         let package = Package.remote(url: "remote", requirement: .branch("master"))
         let versionStub = Version(10, 0, 0)
         xcodeController.selectedVersionStub = .success(versionStub)
-        let graph = ValueGraph.test(packages: [path: ["package": package]])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(packages: [path: ["package": package]])
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -72,8 +72,8 @@ final class GraphLinterTests: TuistUnitTestCase {
         let package = Package.remote(url: "remote", requirement: .branch("master"))
         let versionStub = Version(11, 0, 0)
         xcodeController.selectedVersionStub = .success(versionStub)
-        let graph = ValueGraph.test(packages: [path: ["package": package]])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(packages: [path: ["package": package]])
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -89,8 +89,8 @@ final class GraphLinterTests: TuistUnitTestCase {
         let package = Package.remote(url: "remote", requirement: .branch("master"))
         let error = NSError.test()
         xcodeController.selectedVersionStub = .failure(error)
-        let graph = ValueGraph.test(packages: [path: ["package": package]])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(packages: [path: ["package": package]])
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -114,7 +114,7 @@ final class GraphLinterTests: TuistUnitTestCase {
             targets: [staticFrameworkA, staticFrameworkB, staticLibrary]
         )
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: staticFrameworkA.name, path: path),
                                                       .target(name: staticFrameworkB.name, path: path),
                                                       .target(name: staticLibrary.name, path: path)]),
@@ -123,7 +123,7 @@ final class GraphLinterTests: TuistUnitTestCase {
             .target(name: staticLibrary.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [appTarget.name: appTarget,
@@ -132,7 +132,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                              staticLibrary.name: staticLibrary]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -156,7 +156,7 @@ final class GraphLinterTests: TuistUnitTestCase {
             targets: [staticLibraryA, staticLibraryB, staticFramework]
         )
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: staticLibraryA.name, path: path),
                                                       .target(name: staticLibraryB.name, path: path),
                                                       .target(name: staticFramework.name, path: path)]),
@@ -165,7 +165,7 @@ final class GraphLinterTests: TuistUnitTestCase {
             .target(name: staticFramework.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [appTarget.name: appTarget,
@@ -174,7 +174,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                              staticFramework.name: staticFramework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -190,19 +190,19 @@ final class GraphLinterTests: TuistUnitTestCase {
         let framework = Target.empty(name: "framework", product: .framework)
         let project = Project.empty(path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: bundle.name, path: path): Set([]),
             .target(name: framework.name, path: path): Set([.target(name: bundle.name, path: path)]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [bundle.name: bundle,
                              framework.name: framework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -218,19 +218,19 @@ final class GraphLinterTests: TuistUnitTestCase {
         let application = Target.empty(name: "application", product: .app)
         let project = Project.empty(path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: bundle.name, path: path): Set([]),
             .target(name: application.name, path: path): Set([.target(name: bundle.name, path: path)]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [bundle.name: bundle,
                              application.name: application]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -247,13 +247,13 @@ final class GraphLinterTests: TuistUnitTestCase {
         let uiTests = Target.empty(name: "uiTests", product: .unitTests)
         let project = Project.empty(path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: bundle.name, path: path): Set([]),
             .target(name: unitTests.name, path: path): Set([.target(name: bundle.name, path: path)]),
             .target(name: uiTests.name, path: path): Set([.target(name: bundle.name, path: path)]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [bundle.name: bundle,
@@ -261,7 +261,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                              uiTests.name: uiTests]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -278,13 +278,13 @@ final class GraphLinterTests: TuistUnitTestCase {
         let dynamicFramework = Target.empty(name: "DynamicFramework", product: .framework)
         let project = Project.empty(path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: staticLibrary.name, path: path): Set([.target(name: dynamicFramework.name, path: path)]),
             .target(name: staticFramework.name, path: path): Set([.target(name: dynamicFramework.name, path: path)]),
             .target(name: dynamicFramework.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [staticFramework.name: staticFramework,
@@ -292,7 +292,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                              dynamicFramework.name: dynamicFramework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -309,13 +309,13 @@ final class GraphLinterTests: TuistUnitTestCase {
         let iosStaticLibrary = Target.empty(name: "iOSStaticLibrary", platform: .iOS, product: .staticLibrary)
         let project = Project.empty(path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: macStaticFramework.name, path: path): Set([.target(name: iosStaticFramework.name, path: path), .target(name: iosStaticLibrary.name, path: path)]),
             .target(name: iosStaticFramework.name, path: path): Set([]),
             .target(name: iosStaticLibrary.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [macStaticFramework.name: macStaticFramework,
@@ -323,7 +323,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                              iosStaticLibrary.name: iosStaticLibrary]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -339,19 +339,19 @@ final class GraphLinterTests: TuistUnitTestCase {
         let watchApp = Target.empty(name: "WatchApp", platform: .watchOS, product: .watch2App)
         let project = Project.empty(path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: watchApp.name, path: path): Set([.target(name: watchExtension.name, path: path)]),
             .target(name: watchExtension.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [watchExtension.name: watchExtension,
                              watchApp.name: watchApp]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -367,19 +367,19 @@ final class GraphLinterTests: TuistUnitTestCase {
         let watchApp = Target.empty(name: "WatchApp", platform: .watchOS, product: .watch2App)
         let project = Project.empty(path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: watchApp.name, path: path): Set([.target(name: invalidDependency.name, path: path)]),
             .target(name: invalidDependency.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [invalidDependency.name: invalidDependency,
                              watchApp.name: watchApp]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -409,12 +409,12 @@ final class GraphLinterTests: TuistUnitTestCase {
         let projectCPath: AbsolutePath = "/path/to/c"
         let projectC = Project.empty(path: "/path/to/c", name: "ProjectC", settings: .default)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: targetA.name, path: projectAPath): Set([.target(name: targetB.name, path: projectBPath)]),
             .target(name: targetB.name, path: projectBPath): Set([.target(name: targetC.name, path: projectCPath)]),
             .target(name: targetC.name, path: projectCPath): Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [projectAPath, projectBPath, projectCPath]),
             projects: [projectAPath: projectA,
@@ -425,7 +425,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                       projectCPath: [targetC.name: targetC]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -466,13 +466,13 @@ final class GraphLinterTests: TuistUnitTestCase {
         let projectCPath: AbsolutePath = "/path/to/c"
         let projectC = Project.empty(path: projectCPath, name: "ProjectC", settings: Settings(configurations: mismatchingConfigurations))
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: targetA.name, path: projectAPath): Set([.target(name: targetB.name, path: projectBPath)]),
             .target(name: targetB.name, path: projectBPath): Set([.target(name: targetC.name, path: projectCPath)]),
             .target(name: targetC.name, path: projectCPath): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [projectAPath]),
             projects: [projectAPath: projectA,
@@ -483,7 +483,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                       projectCPath: [targetC.name: targetC]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -526,13 +526,13 @@ final class GraphLinterTests: TuistUnitTestCase {
         let projectCPath: AbsolutePath = "/path/to/c"
         let projectC = Project.empty(path: projectCPath, name: "ProjectC", settings: Settings(configurations: additionalConfigurations))
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: targetA.name, path: projectAPath): Set([.target(name: targetB.name, path: projectBPath)]),
             .target(name: targetB.name, path: projectBPath): Set([.target(name: targetC.name, path: projectCPath)]),
             .target(name: targetC.name, path: projectCPath): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [projectAPath, projectBPath]),
             projects: [projectAPath: projectA,
@@ -543,7 +543,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                       projectCPath: [targetC.name: targetC]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let result = subject.lint(graphTraverser: graphTraverser)
@@ -574,20 +574,20 @@ final class GraphLinterTests: TuistUnitTestCase {
         )
         let project = Project.test(path: path, targets: [app, watchApp, watchExtension])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: watchApp.name, path: path)]),
             .target(name: watchApp.name, path: path): Set([.target(name: watchExtension.name, path: path)]),
             .target(name: watchExtension.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
             targets: [path: [app.name: app, watchApp.name: watchApp, watchExtension.name: watchExtension]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -618,20 +618,20 @@ final class GraphLinterTests: TuistUnitTestCase {
         )
         let project = Project.test(targets: [app, watchApp, watchExtension])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: watchApp.name, path: path)]),
             .target(name: watchApp.name, path: path): Set([.target(name: watchExtension.name, path: path)]),
             .target(name: watchExtension.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
             targets: [path: [app.name: app, watchApp.name: watchApp, watchExtension.name: watchExtension]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -672,19 +672,19 @@ final class GraphLinterTests: TuistUnitTestCase {
             entitlements: entitlementsPath
         )
         let project = Project.test(path: temporaryPath, targets: [app, appClip])
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: temporaryPath): Set([.target(name: appClip.name, path: temporaryPath)]),
             .target(name: appClip.name, path: temporaryPath): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: temporaryPath,
             workspace: Workspace.test(projects: [temporaryPath]),
             projects: [temporaryPath: project],
             targets: [temporaryPath: [app.name: app, appClip.name: appClip]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -717,19 +717,19 @@ final class GraphLinterTests: TuistUnitTestCase {
         )
         let project = Project.test(targets: [app, appClip])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: temporaryPath): Set([.target(name: appClip.name, path: temporaryPath)]),
             .target(name: appClip.name, path: temporaryPath): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: temporaryPath,
             workspace: Workspace.test(projects: [temporaryPath]),
             projects: [temporaryPath: project],
             targets: [temporaryPath: [app.name: app, appClip.name: appClip]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -759,19 +759,19 @@ final class GraphLinterTests: TuistUnitTestCase {
         )
         let project = Project.test(path: path, targets: [app, appClip])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: appClip.name, path: path)]),
             .target(name: appClip.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
             targets: [path: [app.name: app, appClip.name: appClip]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -802,19 +802,19 @@ final class GraphLinterTests: TuistUnitTestCase {
         )
         let project = Project.test(path: path, targets: [app, appClip])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: appClip.name, path: path)]),
             .target(name: appClip.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
             targets: [path: [app.name: app, appClip.name: appClip]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -861,20 +861,20 @@ final class GraphLinterTests: TuistUnitTestCase {
 
         let project = Project.test(path: temporaryPath, targets: [app, appClip1, appClip2])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: temporaryPath): Set([.target(name: appClip1.name, path: temporaryPath), .target(name: appClip2.name, path: temporaryPath)]),
             .target(name: appClip1.name, path: temporaryPath): Set([]),
             .target(name: appClip2.name, path: temporaryPath): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: temporaryPath,
             workspace: Workspace.test(projects: [temporaryPath]),
             projects: [temporaryPath: project],
             targets: [temporaryPath: [app.name: app, appClip1.name: appClip1, appClip2.name: appClip2]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -915,19 +915,19 @@ final class GraphLinterTests: TuistUnitTestCase {
 
         let project = Project.test(path: temporaryPath, targets: [app, appClip, framework])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: temporaryPath): Set([.target(name: appClip.name, path: temporaryPath)]),
             .target(name: appClip.name, path: temporaryPath): Set([.target(name: framework.name, path: temporaryPath)]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: temporaryPath,
             workspace: Workspace.test(projects: [temporaryPath]),
             projects: [temporaryPath: project],
             targets: [temporaryPath: [app.name: app, appClip.name: appClip, framework.name: framework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -954,19 +954,19 @@ final class GraphLinterTests: TuistUnitTestCase {
 
         let project = Project.test(path: path, targets: [tool, dynamic])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: tool.name, path: path): Set([.target(name: dynamic.name, path: path)]),
             .target(name: dynamic.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
             targets: [path: [tool.name: tool, dynamic.name: dynamic]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -998,19 +998,19 @@ final class GraphLinterTests: TuistUnitTestCase {
 
         let project = Project.test(path: path, targets: [tool, dynamic])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: tool.name, path: path): Set([.target(name: dynamic.name, path: path)]),
             .target(name: dynamic.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
             targets: [path: [tool.name: tool, dynamic.name: dynamic]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -1044,20 +1044,20 @@ final class GraphLinterTests: TuistUnitTestCase {
 
         let project = Project.test(path: path, targets: [tool, staticLib, staticFmwk])
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: tool.name, path: path): Set([.target(name: staticLib.name, path: path), .target(name: staticFmwk.name, path: path)]),
             .target(name: staticLib.name, path: path): Set([]),
             .target(name: staticFmwk.name, path: path): Set([]),
         ]
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
             targets: [path: [tool.name: tool, staticFmwk.name: staticFmwk, staticLib.name: staticLib]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -1080,14 +1080,14 @@ final class GraphLinterTests: TuistUnitTestCase {
             targets: [frameworkA, frameworkB]
         )
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: frameworkA.name, path: frameworks1.path),
                                                       .target(name: frameworkB.name, path: frameworks1.path)]),
         ]
 
         let project = Project.test(path: path, targets: [appTarget, frameworkA, frameworkB])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
@@ -1095,7 +1095,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                       frameworks1.path: [frameworkA.name: frameworkA, frameworkB.name: frameworkB]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -1132,7 +1132,7 @@ final class GraphLinterTests: TuistUnitTestCase {
             targets: [frameworkE, frameworkF]
         )
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             .target(name: app.name, path: path): Set([.target(name: frameworkA.name, path: frameworks1.path),
                                                       .target(name: frameworkB.name, path: frameworks1.path),
                                                       .target(name: frameworkC.name, path: frameworks2.path),
@@ -1143,7 +1143,7 @@ final class GraphLinterTests: TuistUnitTestCase {
 
         let project = Project.test(path: path, targets: [appTarget, frameworkA, frameworkB, frameworkC, frameworkD, frameworkE, frameworkF])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [path]),
             projects: [path: project],
@@ -1153,7 +1153,7 @@ final class GraphLinterTests: TuistUnitTestCase {
                       frameworks3.path: [frameworkE.name: frameworkE, frameworkF.name: frameworkF]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)
@@ -1182,7 +1182,7 @@ final class GraphLinterTests: TuistUnitTestCase {
             targets: [appTarget, frameworkA, frameworkB, frameworkC, frameworkD, frameworkE, frameworkF]
         )
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             workspace: Workspace.test(projects: [project.path]),
             projects: [
@@ -1201,7 +1201,7 @@ final class GraphLinterTests: TuistUnitTestCase {
             ],
             dependencies: [:]
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let got = subject.lint(graphTraverser: graphTraverser)

Tests/TuistGeneratorTests/Linter/StaticProductsGraphLinterTests.swift

@@ -29,15 +29,15 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let framework = Target.test(name: "Framework", product: .framework)
         let project = Project.test(path: "/tmp/app", name: "AppProject")
         let package = Package.remote(url: "https://test.tuist.io", requirement: .branch("main"))
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let frameworkDependency = ValueGraphDependency.target(name: framework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let frameworkDependency = GraphDependency.target(name: framework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkDependency, .packageProduct(path: path, product: "Package")]),
             frameworkDependency: Set([.packageProduct(path: path, product: "Package")]),
             .packageProduct(path: path, product: "Package"): Set(),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             packages: [path: ["Package": package]],
@@ -45,7 +45,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              framework.name: framework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -62,23 +62,23 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let app = Target.test(name: "App")
         let framework = Target.test(name: "Framework", product: .framework)
         let project = Project.test(targets: [app, framework])
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let frameworkDependency = ValueGraphDependency.target(name: framework.name, path: path)
-        let libraryDependency = ValueGraphDependency.testLibrary(path: "/path/to/library", publicHeaders: "/path/to/library/include", linking: .static)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let frameworkDependency = GraphDependency.target(name: framework.name, path: path)
+        let libraryDependency = GraphDependency.testLibrary(path: "/path/to/library", publicHeaders: "/path/to/library/include", linking: .static)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkDependency, libraryDependency]),
             frameworkDependency: Set([libraryDependency]),
             libraryDependency: Set(),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
                              framework.name: framework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -97,16 +97,16 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let framework = Target.test(name: "Framework", product: .framework)
         let project = Project.test(targets: [app, framework, staticFramework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
-        let frameworkDependency = ValueGraphDependency.target(name: framework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
+        let frameworkDependency = GraphDependency.target(name: framework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([staticFrameworkDependency, frameworkDependency]),
             frameworkDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set(),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -114,7 +114,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFramework.name: staticFramework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -137,15 +137,15 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let frameworkC = Target.test(name: "FrameworkC", product: .framework)
         let project = Project.test(targets: [app, staticFrameworkA, staticFrameworkB, staticFrameworkC, frameworkA, frameworkB, frameworkC])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let staticFrameworkAdependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
-        let staticFrameworkBdependency = ValueGraphDependency.target(name: staticFrameworkB.name, path: path)
-        let staticFrameworkCdependency = ValueGraphDependency.target(name: staticFrameworkC.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let frameworkBDependency = ValueGraphDependency.target(name: frameworkB.name, path: path)
-        let frameworkCDependency = ValueGraphDependency.target(name: frameworkC.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let staticFrameworkAdependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
+        let staticFrameworkBdependency = GraphDependency.target(name: staticFrameworkB.name, path: path)
+        let staticFrameworkCdependency = GraphDependency.target(name: staticFrameworkC.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let frameworkBDependency = GraphDependency.target(name: frameworkB.name, path: path)
+        let frameworkCDependency = GraphDependency.target(name: frameworkC.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([staticFrameworkCdependency, frameworkADependency]),
             frameworkADependency: Set([frameworkBDependency]),
             frameworkBDependency: Set([frameworkCDependency]),
@@ -154,7 +154,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             staticFrameworkBdependency: Set([staticFrameworkCdependency]),
             staticFrameworkCdependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -166,7 +166,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              frameworkC.name: frameworkC]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -189,15 +189,15 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let frameworkC = Target.test(name: "FrameworkC", product: .framework)
         let project = Project.test(targets: [app, staticFrameworkA, staticFrameworkB, staticFrameworkC, frameworkA, frameworkB, frameworkC])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let staticFrameworkAdependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
-        let staticFrameworkBdependency = ValueGraphDependency.target(name: staticFrameworkB.name, path: path)
-        let staticFrameworkCdependency = ValueGraphDependency.target(name: staticFrameworkC.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let frameworkBDependency = ValueGraphDependency.target(name: frameworkB.name, path: path)
-        let frameworkCDependency = ValueGraphDependency.target(name: frameworkC.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let staticFrameworkAdependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
+        let staticFrameworkBdependency = GraphDependency.target(name: staticFrameworkB.name, path: path)
+        let staticFrameworkCdependency = GraphDependency.target(name: staticFrameworkC.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let frameworkBDependency = GraphDependency.target(name: frameworkB.name, path: path)
+        let frameworkCDependency = GraphDependency.target(name: frameworkC.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([staticFrameworkCdependency, frameworkADependency]),
             frameworkADependency: Set([frameworkBDependency, frameworkCDependency]),
             frameworkBDependency: Set([frameworkCDependency]),
@@ -206,7 +206,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             staticFrameworkBdependency: Set([staticFrameworkCdependency]),
             staticFrameworkCdependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -218,7 +218,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              frameworkC.name: frameworkC]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -240,14 +240,14 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let frameworkD = Target.test(name: "FrameworkD", product: .framework)
         let project = Project.test(targets: [app, frameworkA, frameworkB, frameworkC, staticFrameworkA])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let staticFrameworkAdependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let frameworkBDependency = ValueGraphDependency.target(name: frameworkB.name, path: path)
-        let frameworkCDependency = ValueGraphDependency.target(name: frameworkC.name, path: path)
-        let frameworkDDependency = ValueGraphDependency.target(name: frameworkD.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let staticFrameworkAdependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let frameworkBDependency = GraphDependency.target(name: frameworkB.name, path: path)
+        let frameworkCDependency = GraphDependency.target(name: frameworkC.name, path: path)
+        let frameworkDDependency = GraphDependency.target(name: frameworkD.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkADependency, staticFrameworkAdependency]),
             frameworkADependency: Set([frameworkBDependency, frameworkCDependency]),
             frameworkBDependency: Set([frameworkCDependency]),
@@ -255,7 +255,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             staticFrameworkAdependency: Set([]),
             frameworkDDependency: Set([frameworkCDependency, staticFrameworkAdependency]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -266,7 +266,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              frameworkD.name: frameworkD]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -286,16 +286,16 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let framework = Target.test(name: "Framework", product: .framework)
         let project = Project.test(targets: [app, staticFramework, framework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
-        let frameworkDependency = ValueGraphDependency.target(name: framework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
+        let frameworkDependency = GraphDependency.target(name: framework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([staticFrameworkDependency, frameworkDependency]),
             frameworkDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -303,7 +303,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              framework.name: framework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -324,15 +324,15 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let frameworkC = Target.test(name: "FrameworkC", product: .framework)
         let project = Project.test(targets: [app, frameworkA, frameworkB, frameworkC, staticFrameworkA, staticFrameworkB, staticFrameworkC])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let frameworkBDependency = ValueGraphDependency.target(name: frameworkB.name, path: path)
-        let frameworkCDependency = ValueGraphDependency.target(name: frameworkC.name, path: path)
-        let staticFrameworkAdependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
-        let staticFrameworkBdependency = ValueGraphDependency.target(name: staticFrameworkB.name, path: path)
-        let staticFrameworkCdependency = ValueGraphDependency.target(name: staticFrameworkC.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let frameworkBDependency = GraphDependency.target(name: frameworkB.name, path: path)
+        let frameworkCDependency = GraphDependency.target(name: frameworkC.name, path: path)
+        let staticFrameworkAdependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
+        let staticFrameworkBdependency = GraphDependency.target(name: staticFrameworkB.name, path: path)
+        let staticFrameworkCdependency = GraphDependency.target(name: staticFrameworkC.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([staticFrameworkBdependency, staticFrameworkAdependency, frameworkADependency]),
             frameworkADependency: Set([frameworkBDependency]),
             frameworkBDependency: Set([frameworkCDependency]),
@@ -341,7 +341,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             staticFrameworkBdependency: Set([staticFrameworkCdependency]),
             staticFrameworkCdependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -353,7 +353,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFrameworkC.name: staticFrameworkC]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -370,16 +370,16 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let frameworkTests = Target.test(name: "FrameworkTests", product: .unitTests)
         let project = Project.test(targets: [app, staticFramework, frameworkTests])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
-        let frameworkTestsDependency = ValueGraphDependency.target(name: frameworkTests.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
+        let frameworkTestsDependency = GraphDependency.target(name: frameworkTests.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set([]),
             frameworkTestsDependency: Set([staticFrameworkDependency]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -387,7 +387,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              frameworkTests.name: frameworkTests]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -405,18 +405,18 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let frameworkTests = Target.test(name: "FrameworkTests", product: .unitTests)
         let project = Project.test(targets: [app, staticFramework, frameworkTests])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let frameworkDependency = ValueGraphDependency.target(name: framework.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
-        let frameworkTestsDependency = ValueGraphDependency.target(name: frameworkTests.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let frameworkDependency = GraphDependency.target(name: framework.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
+        let frameworkTestsDependency = GraphDependency.target(name: frameworkTests.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([]),
             frameworkDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set([]),
             frameworkTestsDependency: Set([frameworkDependency, staticFrameworkDependency]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -425,7 +425,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              frameworkTests.name: frameworkTests]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -444,16 +444,16 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let staticFramework = Target.test(name: "StaticFramework", product: .staticFramework)
         let project = Project.test(targets: [app, appTestsTarget, staticFramework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appTestsDependency = ValueGraphDependency.target(name: appTestsTarget.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appTestsDependency = GraphDependency.target(name: appTestsTarget.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([staticFrameworkDependency]),
             appTestsDependency: Set([staticFrameworkDependency, appDependency]),
             staticFrameworkDependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -461,7 +461,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFramework.name: staticFramework]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -494,22 +494,22 @@ class StaticProductsGraphLinterTests: XCTestCase {
                                              staticFrameworkA, staticFrameworkB, staticFrameworkC,
                                              staticFrameworkATests, staticFrameworkBTests, staticFrameworkCTests])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appTestsDependency = ValueGraphDependency.target(name: appTests.name, path: path)
-        let appUITestsDependency = ValueGraphDependency.target(name: appUITests.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let frameworkBDependency = ValueGraphDependency.target(name: frameworkB.name, path: path)
-        let frameworkCDependency = ValueGraphDependency.target(name: frameworkC.name, path: path)
-        let frameworkTestsDependency = ValueGraphDependency.target(name: frameworkTests.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appTestsDependency = GraphDependency.target(name: appTests.name, path: path)
+        let appUITestsDependency = GraphDependency.target(name: appUITests.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let frameworkBDependency = GraphDependency.target(name: frameworkB.name, path: path)
+        let frameworkCDependency = GraphDependency.target(name: frameworkC.name, path: path)
+        let frameworkTestsDependency = GraphDependency.target(name: frameworkTests.name, path: path)
 
-        let staticFrameworkADependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
-        let staticFrameworkBDependency = ValueGraphDependency.target(name: staticFrameworkB.name, path: path)
-        let staticFrameworkCDependency = ValueGraphDependency.target(name: staticFrameworkC.name, path: path)
-        let staticFrameworkATestsDependency = ValueGraphDependency.target(name: staticFrameworkATests.name, path: path)
-        let staticFrameworkBTestsDependency = ValueGraphDependency.target(name: staticFrameworkBTests.name, path: path)
-        let staticFrameworkCTestsDependency = ValueGraphDependency.target(name: staticFrameworkCTests.name, path: path)
+        let staticFrameworkADependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
+        let staticFrameworkBDependency = GraphDependency.target(name: staticFrameworkB.name, path: path)
+        let staticFrameworkCDependency = GraphDependency.target(name: staticFrameworkC.name, path: path)
+        let staticFrameworkATestsDependency = GraphDependency.target(name: staticFrameworkATests.name, path: path)
+        let staticFrameworkBTestsDependency = GraphDependency.target(name: staticFrameworkBTests.name, path: path)
+        let staticFrameworkCTestsDependency = GraphDependency.target(name: staticFrameworkCTests.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkADependency]),
             appTestsDependency: Set([appDependency]),
             appUITestsDependency: Set([appDependency]),
@@ -524,7 +524,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             staticFrameworkBTestsDependency: Set([staticFrameworkBDependency, frameworkBDependency]),
             staticFrameworkCTestsDependency: Set([staticFrameworkCDependency, staticFrameworkBDependency]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -542,7 +542,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFrameworkCTests.name: staticFrameworkCTests]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -570,18 +570,18 @@ class StaticProductsGraphLinterTests: XCTestCase {
                                              frameworkA, frameworkB, frameworkC, frameworkTests,
                                              staticFrameworkA, staticFrameworkB, staticFrameworkC])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appTestsDependency = ValueGraphDependency.target(name: appTests.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let frameworkBDependency = ValueGraphDependency.target(name: frameworkB.name, path: path)
-        let frameworkCDependency = ValueGraphDependency.target(name: frameworkC.name, path: path)
-        let frameworkTestsDependency = ValueGraphDependency.target(name: frameworkTests.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appTestsDependency = GraphDependency.target(name: appTests.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let frameworkBDependency = GraphDependency.target(name: frameworkB.name, path: path)
+        let frameworkCDependency = GraphDependency.target(name: frameworkC.name, path: path)
+        let frameworkTestsDependency = GraphDependency.target(name: frameworkTests.name, path: path)
 
-        let staticFrameworkADependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
-        let staticFrameworkBDependency = ValueGraphDependency.target(name: staticFrameworkB.name, path: path)
-        let staticFrameworkCDependency = ValueGraphDependency.target(name: staticFrameworkC.name, path: path)
+        let staticFrameworkADependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
+        let staticFrameworkBDependency = GraphDependency.target(name: staticFrameworkB.name, path: path)
+        let staticFrameworkCDependency = GraphDependency.target(name: staticFrameworkC.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkADependency]),
             appTestsDependency: Set([appDependency, staticFrameworkADependency]),
             frameworkADependency: Set([frameworkBDependency, staticFrameworkADependency]),
@@ -592,7 +592,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             staticFrameworkBDependency: Set(),
             staticFrameworkCDependency: Set(),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -606,7 +606,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFrameworkC.name: staticFrameworkC]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -629,20 +629,20 @@ class StaticProductsGraphLinterTests: XCTestCase {
 
         let project = Project.test(targets: [app, appTests, appUITests, frameworkA, staticFrameworkA])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appTestsDependency = ValueGraphDependency.target(name: appTests.name, path: path)
-        let appUITestsDependency = ValueGraphDependency.target(name: appUITests.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let staticFrameworkADependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appTestsDependency = GraphDependency.target(name: appTests.name, path: path)
+        let appUITestsDependency = GraphDependency.target(name: appUITests.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let staticFrameworkADependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkADependency]),
             appTestsDependency: Set([appDependency, staticFrameworkADependency]),
             appUITestsDependency: Set([appDependency, frameworkADependency, staticFrameworkADependency]),
             frameworkADependency: Set([staticFrameworkADependency]),
             staticFrameworkADependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -652,7 +652,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFrameworkA.name: staticFrameworkA]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -673,18 +673,18 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let staticFrameworkA = Target.test(name: "StaticFrameworkA", product: .staticFramework)
         let project = Project.test(targets: [app, appUITests, frameworkA, staticFrameworkA])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appUITestsDependency = ValueGraphDependency.target(name: appUITests.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let staticFrameworkADependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appUITestsDependency = GraphDependency.target(name: appUITests.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let staticFrameworkADependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkADependency]),
             appUITestsDependency: Set([appDependency, staticFrameworkADependency]),
             frameworkADependency: Set([staticFrameworkADependency]),
             staticFrameworkADependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -693,7 +693,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFrameworkA.name: staticFrameworkA]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -716,18 +716,18 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let staticFrameworkA = Target.test(name: "StaticFrameworkA", product: .staticFramework)
         let project = Project.test(targets: [app, appUITests, frameworkA, staticFrameworkA])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appUITestsDependency = ValueGraphDependency.target(name: appUITests.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let staticFrameworkADependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appUITestsDependency = GraphDependency.target(name: appUITests.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let staticFrameworkADependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkADependency]),
             appUITestsDependency: Set([appDependency, staticFrameworkADependency, frameworkADependency]),
             frameworkADependency: Set([staticFrameworkADependency]),
             staticFrameworkADependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -736,7 +736,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFrameworkA.name: staticFrameworkA]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -758,18 +758,18 @@ class StaticProductsGraphLinterTests: XCTestCase {
 
         // App ----> Framework A
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appUITestsDependency = ValueGraphDependency.target(name: appUITests.name, path: path)
-        let frameworkADependency = ValueGraphDependency.target(name: frameworkA.name, path: path)
-        let staticFrameworkADependency = ValueGraphDependency.target(name: staticFrameworkA.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appUITestsDependency = GraphDependency.target(name: appUITests.name, path: path)
+        let frameworkADependency = GraphDependency.target(name: frameworkA.name, path: path)
+        let staticFrameworkADependency = GraphDependency.target(name: staticFrameworkA.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             appDependency: Set([frameworkADependency, staticFrameworkADependency]),
             appUITestsDependency: Set([appDependency, staticFrameworkADependency, frameworkADependency]),
             frameworkADependency: Set([staticFrameworkADependency]),
             staticFrameworkADependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [app.name: app,
@@ -778,7 +778,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
                              staticFrameworkA.name: staticFrameworkA]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -798,17 +798,17 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let staticFramework = Target.test(name: "StaticFramework", product: .staticFramework)
         let project = Project.test(targets: [app, appExtension, staticFramework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appExtensionDependency = ValueGraphDependency.target(name: appExtension.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appExtensionDependency = GraphDependency.target(name: appExtension.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             // apps declare they bundle extensions via dependencies
             appDependency: Set([staticFrameworkDependency, appExtensionDependency]),
             appExtensionDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [
@@ -818,7 +818,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             ]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -836,19 +836,19 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let staticFramework = Target.test(name: "StaticFramework", product: .staticFramework)
         let project = Project.test(targets: [app, appExtension, framework, staticFramework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appExtensionDependency = ValueGraphDependency.target(name: appExtension.name, path: path)
-        let frameworkDependency = ValueGraphDependency.target(name: framework.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appExtensionDependency = GraphDependency.target(name: appExtension.name, path: path)
+        let frameworkDependency = GraphDependency.target(name: framework.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             // apps declare they bundle extensions via dependencies
             appDependency: Set([staticFrameworkDependency, appExtensionDependency]),
             appExtensionDependency: Set([staticFrameworkDependency, frameworkDependency]),
             frameworkDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [
@@ -859,7 +859,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             ]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -878,17 +878,17 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let staticFramework = Target.test(name: "StaticFramework", product: .staticFramework)
         let project = Project.test(targets: [app, appClip, staticFramework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appClipDependency = ValueGraphDependency.target(name: appClip.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appClipDependency = GraphDependency.target(name: appClip.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             // apps declare they bundle app clips via dependencies
             appDependency: Set([staticFrameworkDependency, appClipDependency]),
             appClipDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [
@@ -898,7 +898,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             ]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -916,19 +916,19 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let staticFramework = Target.test(name: "StaticFramework", product: .staticFramework)
         let project = Project.test(targets: [app, appClip, framework, staticFramework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let appClipDependency = ValueGraphDependency.target(name: appClip.name, path: path)
-        let frameworkDependency = ValueGraphDependency.target(name: framework.name, path: path)
-        let staticFrameworkDependency = ValueGraphDependency.target(name: staticFramework.name, path: path)
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let appClipDependency = GraphDependency.target(name: appClip.name, path: path)
+        let frameworkDependency = GraphDependency.target(name: framework.name, path: path)
+        let staticFrameworkDependency = GraphDependency.target(name: staticFramework.name, path: path)
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             // apps declare they bundle app clips via dependencies
             appDependency: Set([staticFrameworkDependency, appClipDependency]),
             appClipDependency: Set([frameworkDependency, staticFrameworkDependency]),
             frameworkDependency: Set([staticFrameworkDependency]),
             staticFrameworkDependency: Set([]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [
@@ -939,7 +939,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             ]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -958,19 +958,19 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let watchAppExtension = Target.test(name: "WatchAppExtension", platform: .watchOS, product: .watch2Extension)
         let project = Project.test(targets: [app, watchApp, watchAppExtension])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let watchAppDependency = ValueGraphDependency.target(name: watchApp.name, path: path)
-        let watchAppExtensionDependency = ValueGraphDependency.target(name: watchAppExtension.name, path: path)
-        let swiftPackage = ValueGraphDependency.packageProduct(path: "/path/to/package", product: "LocalPackage")
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let watchAppDependency = GraphDependency.target(name: watchApp.name, path: path)
+        let watchAppExtensionDependency = GraphDependency.target(name: watchAppExtension.name, path: path)
+        let swiftPackage = GraphDependency.packageProduct(path: "/path/to/package", product: "LocalPackage")
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             // apps declare they bundle watch apps via dependencies
             appDependency: Set([swiftPackage, watchAppDependency]),
             // apps declare they bundle extensions via dependencies
             watchAppDependency: Set([watchAppExtensionDependency]),
             watchAppExtensionDependency: Set([swiftPackage]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [
@@ -980,7 +980,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             ]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -998,13 +998,13 @@ class StaticProductsGraphLinterTests: XCTestCase {
         let watchFramework = Target.test(name: "WatchFramework", platform: .watchOS, product: .framework)
         let project = Project.test(targets: [app, watchApp, watchAppExtension, watchFramework])
 
-        let appDependency = ValueGraphDependency.target(name: app.name, path: path)
-        let watchAppDependency = ValueGraphDependency.target(name: watchApp.name, path: path)
-        let watchAppExtensionDependency = ValueGraphDependency.target(name: watchAppExtension.name, path: path)
-        let watchFrameworkDependency = ValueGraphDependency.target(name: watchFramework.name, path: path)
-        let swiftPackage = ValueGraphDependency.packageProduct(path: "/path/to/package", product: "LocalPackage")
+        let appDependency = GraphDependency.target(name: app.name, path: path)
+        let watchAppDependency = GraphDependency.target(name: watchApp.name, path: path)
+        let watchAppExtensionDependency = GraphDependency.target(name: watchAppExtension.name, path: path)
+        let watchFrameworkDependency = GraphDependency.target(name: watchFramework.name, path: path)
+        let swiftPackage = GraphDependency.packageProduct(path: "/path/to/package", product: "LocalPackage")
 
-        let dependencies: [ValueGraphDependency: Set<ValueGraphDependency>] = [
+        let dependencies: [GraphDependency: Set<GraphDependency>] = [
             // apps declare they bundle watch apps via dependencies
             appDependency: Set([swiftPackage, watchAppDependency]),
             // apps declare they bundle extensions via dependencies
@@ -1012,7 +1012,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             watchAppExtensionDependency: Set([swiftPackage, watchFrameworkDependency]),
             watchFrameworkDependency: Set([swiftPackage]),
         ]
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             path: path,
             projects: [path: project],
             targets: [path: [
@@ -1023,7 +1023,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
             ]],
             dependencies: dependencies
         )
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // When
         let results = subject.lint(graphTraverser: graphTraverser)
@@ -1036,7 +1036,7 @@ class StaticProductsGraphLinterTests: XCTestCase {
 
     // MARK: - Helpers
 
-    private func warning(product node: String, type: String = "Target", linkedBy: [ValueGraphDependency]) -> LintingIssue {
+    private func warning(product node: String, type: String = "Target", linkedBy: [GraphDependency]) -> LintingIssue {
         let reason = "\(type) \'\(node)\' has been linked from \(linkedBy.map(\.description).listed()), it is a static product so may introduce unwanted side effects.".uppercasingFirst
         return LintingIssue(
             reason: reason,

Tests/TuistGeneratorTests/Utils/CocoaPodsInteractorTests.swift

@@ -38,8 +38,8 @@ final class CocoaPodsInteractorTests: TuistUnitTestCase {
         system.whichStub = { _ in
             throw NSError.test()
         }
-        let graph = ValueGraph.test(dependencies: [ValueGraphDependency.cocoapods(path: "/"): Set()])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(dependencies: [GraphDependency.cocoapods(path: "/"): Set()])
+        let graphTraverser = GraphTraverser(graph: graph)
 
         // Then
         XCTAssertThrowsSpecific(
@@ -50,8 +50,8 @@ final class CocoaPodsInteractorTests: TuistUnitTestCase {
 
     func test_install_when_theCocoaPodsFromBundlerCanBeUsed() throws {
         // Given
-        let graph = ValueGraph.test(dependencies: [ValueGraphDependency.cocoapods(path: "/"): Set()])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(dependencies: [GraphDependency.cocoapods(path: "/"): Set()])
+        let graphTraverser = GraphTraverser(graph: graph)
 
         system.succeedCommand(["bundle", "show", "cocoapods"])
         system.succeedCommand(["bundle", "exec", "pod", "install", "--project-directory=/"])
@@ -65,8 +65,8 @@ final class CocoaPodsInteractorTests: TuistUnitTestCase {
 
     func test_install_when_theCocoaPodsFromTheSystemCanBeUsed() throws {
         // Given
-        let graph = ValueGraph.test(dependencies: [ValueGraphDependency.cocoapods(path: "/"): Set()])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(dependencies: [GraphDependency.cocoapods(path: "/"): Set()])
+        let graphTraverser = GraphTraverser(graph: graph)
 
         system.errorCommand(["bundle", "show", "cocoapods"])
         system.whichStub = {
@@ -84,8 +84,8 @@ final class CocoaPodsInteractorTests: TuistUnitTestCase {
 
     func test_install_when_theCocoaPodsSpecsRepoIsOutdated() throws {
         // Given
-        let graph = ValueGraph.test(dependencies: [ValueGraphDependency.cocoapods(path: "/"): Set()])
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graph = Graph.test(dependencies: [GraphDependency.cocoapods(path: "/"): Set()])
+        let graphTraverser = GraphTraverser(graph: graph)
 
         system.succeedCommand(["bundle", "show", "cocoapods"])
         system.errorCommand(["bundle", "exec", "pod", "install", "--project-directory=/"], error: "[!] CocoaPods could not find compatible versions for pod")

Tests/TuistGraphTests/Graph/GraphDependencyTests.swift

@@ -4,10 +4,10 @@ import XCTest
 @testable import TuistGraph
 @testable import TuistSupportTesting
 
-final class ValueGraphDependencyTests: TuistUnitTestCase {
+final class GraphDependencyTests: TuistUnitTestCase {
     func test_codable_target() {
         // Given
-        let subject = ValueGraphDependency.testTarget()
+        let subject = GraphDependency.testTarget()
 
         // Then
         XCTAssertCodable(subject)
@@ -15,7 +15,7 @@ final class ValueGraphDependencyTests: TuistUnitTestCase {
 
     func test_codable_framework() {
         // Given
-        let subject = ValueGraphDependency.testFramework()
+        let subject = GraphDependency.testFramework()
 
         // Then
         XCTAssertCodable(subject)

Tests/TuistGraphTests/Graph/GraphTargetTests.swift

@@ -4,10 +4,10 @@ import XCTest
 @testable import TuistGraph
 @testable import TuistSupportTesting
 
-final class ValueGraphTargetTests: TuistUnitTestCase {
+final class GraphTargetTests: TuistUnitTestCase {
     func test_codable() {
         // Given
-        let subject = ValueGraphTarget.test()
+        let subject = GraphTarget.test()
 
         // Then
         XCTAssertCodable(subject)

Tests/TuistGraphTests/Graph/GraphTests.swift

@@ -4,10 +4,10 @@ import XCTest
 @testable import TuistGraph
 @testable import TuistSupportTesting
 
-final class ValueGraphTests: TuistUnitTestCase {
+final class GraphTests: TuistUnitTestCase {
     func test_codable() {
         // Given
-        let subject = ValueGraph.test(name: "name", path: "/path/to")
+        let subject = Graph.test(name: "name", path: "/path/to")
 
         // Then
         XCTAssertCodable(subject)

Tests/TuistGraphTests/Models/ProjectTests.swift

@@ -31,7 +31,7 @@ final class ProjectTests: XCTestCase {
             framework, app, appTests, frameworkTests,
         ])
 
-        let graph = ValueGraph.test(
+        let graph = Graph.test(
             projects: [project.path: project],
             targets: [
                 project.path: [

Tests/TuistIntegrationTests/Generator/MultipleConfigurationsIntegrationTests.swift

@@ -315,10 +315,10 @@ final class MultipleConfigurationsIntegrationTests: TuistUnitTestCase {
         let subject = DescriptorGenerator()
         let writer = XcodeProjWriter()
         let linter = GraphLinter()
-        let graphLoader = ValueGraphLoader()
+        let graphLoader = GraphLoader()
 
         let graph = try graphLoader.loadWorkspace(workspace: models.workspace, projects: models.projects)
-        let graphTraverser = ValueGraphTraverser(graph: graph)
+        let graphTraverser = GraphTraverser(graph: graph)
         try linter.lint(graphTraverser: graphTraverser).printAndThrowIfNeeded()
         let descriptor = try subject.generateWorkspace(graphTraverser: graphTraverser)
         try writer.write(workspace: descriptor)

Tests/TuistIntegrationTests/Generator/StableStructureIntegrationTests.swift

@@ -35,7 +35,7 @@ final class StableXcodeProjIntegrationTests: TuistTestCase {
             )
             let modelGenerator = TestModelGenerator(rootPath: temporaryPath, config: config)
             let graph = try modelGenerator.generate()
-            let graphTraverser = ValueGraphTraverser(graph: graph)
+            let graphTraverser = GraphTraverser(graph: graph)
 
             let workspaceDescriptor = try subject.generateWorkspace(graphTraverser: graphTraverser)
 

Tests/TuistIntegrationTests/Generator/TestModelGenerator.swift

@@ -27,9 +27,9 @@ final class TestModelGenerator {
         self.config = config
     }
 
-    func generate() throws -> ValueGraph {
+    func generate() throws -> Graph {
         let models = try createModels()
-        let graphLoader = ValueGraphLoader(
+        let graphLoader = GraphLoader(
             frameworkMetadataProvider: MockFrameworkMetadataProvider(),
             libraryMetadataProvider: MockLibraryMetadataProvider(),
             xcframeworkMetadataProvider: MockXCFrameworkMetadataProvider(),