[format] Apply auto-formatting

Bug: 430616180
Change-Id: I12f41e8c87913481f05f3bf350acdb88ac08c163
Reviewed-on: https://chrome-internal-review.googlesource.com/c/v8/fuzzilli/+/9155818
Commit-Queue: Matthias Liedtke <mliedtke@google.com>
Reviewed-by: Michael Achenbach <machenbach@google.com>

Author: Liedtke

Package.swift

@@ -19,10 +19,10 @@ import PackageDescription
 let package = Package(
     name: "Fuzzilli",
     platforms: [
-        .macOS(.v13),
+        .macOS(.v13)
     ],
     products: [
-        .library(name: "Fuzzilli",targets: ["Fuzzilli"]),
+        .library(name: "Fuzzilli", targets: ["Fuzzilli"])
     ],
     dependencies: [
         // We use an exact version here as we also use this version to generate the .pb.swift to
@@ -31,62 +31,74 @@ let package = Package(
         // regenerated, whenever the version is bumped.
         .package(url: "https://github.com/apple/swift-protobuf.git", exact: "1.35.0"),
         .package(
-          url: "https://github.com/apple/swift-collections.git",
-          .upToNextMinor(from: "1.2.0")
+            url: "https://github.com/apple/swift-collections.git",
+            .upToNextMinor(from: "1.2.0")
         ),
     ],
     targets: [
-        .target(name: "libsocket",
-                dependencies: []),
+        .target(
+            name: "libsocket",
+            dependencies: []),
 
-        .target(name: "libreprl",
-                dependencies: []),
+        .target(
+            name: "libreprl",
+            dependencies: []),
 
-        .target(name: "libcoverage",
-                dependencies: [],
-                cSettings: [.unsafeFlags(["-O3"])],     // Using '-c release' when building uses '-O2', so '-O3' provides a performance gain
-                linkerSettings: [.linkedLibrary("rt", .when(platforms: [.linux]))]),
+        .target(
+            name: "libcoverage",
+            dependencies: [],
+            cSettings: [.unsafeFlags(["-O3"])],  // Using '-c release' when building uses '-O2', so '-O3' provides a performance gain
+            linkerSettings: [.linkedLibrary("rt", .when(platforms: [.linux]))]),
 
-        .target(name: "Fuzzilli",
-                dependencies: [
-                    .product(name: "SwiftProtobuf", package: "swift-protobuf"),
-                    .product(name: "Collections", package: "swift-collections"),
-                    "libsocket",
-                    "libreprl",
-                    "libcoverage"],
-                exclude: [
-                    "Protobuf/operations.proto",
-                    "Protobuf/program.proto",
-                    "Protobuf/sync.proto",
-                    "Protobuf/README.md",
-                    "Protobuf/gen_programproto.py"],
-                resources: [
-                    // The ast.proto file is required by the node.js parser
-                    .copy("Protobuf/ast.proto"),
-                    .copy("Compiler/Parser")]),
+        .target(
+            name: "Fuzzilli",
+            dependencies: [
+                .product(name: "SwiftProtobuf", package: "swift-protobuf"),
+                .product(name: "Collections", package: "swift-collections"),
+                "libsocket",
+                "libreprl",
+                "libcoverage",
+            ],
+            exclude: [
+                "Protobuf/operations.proto",
+                "Protobuf/program.proto",
+                "Protobuf/sync.proto",
+                "Protobuf/README.md",
+                "Protobuf/gen_programproto.py",
+            ],
+            resources: [
+                // The ast.proto file is required by the node.js parser
+                .copy("Protobuf/ast.proto"),
+                .copy("Compiler/Parser"),
+            ]),
 
-        .executableTarget(name: "REPRLRun",
-                dependencies: ["libreprl"]),
+        .executableTarget(
+            name: "REPRLRun",
+            dependencies: ["libreprl"]),
 
-        .executableTarget(name: "FuzzilliCli",
-                dependencies: ["Fuzzilli"]),
+        .executableTarget(
+            name: "FuzzilliCli",
+            dependencies: ["Fuzzilli"]),
 
-        .executableTarget(name: "FuzzILTool",
-                dependencies: ["Fuzzilli"]),
+        .executableTarget(
+            name: "FuzzILTool",
+            dependencies: ["Fuzzilli"]),
 
         // Tool that runs d8 in Dumpling mode. First time it runs with Maglev
         // and Turbofan. Second time without. In both runs frames are dumped
         // in certain points to the files. The dumps are later compared for
         // equality. If they are not equal, it means that there's likely a bug
         // in V8.
-        .executableTarget(name: "RelateTool",
-                dependencies: ["Fuzzilli"]),
+        .executableTarget(
+            name: "RelateTool",
+            dependencies: ["Fuzzilli"]),
 
         .executableTarget(name: "FuzzilliDetectMissingBuiltins", dependencies: ["Fuzzilli"]),
 
-        .testTarget(name: "FuzzilliTests",
-                    dependencies: ["Fuzzilli"],
-                    resources: [.copy("CompilerTests")]),
+        .testTarget(
+            name: "FuzzilliTests",
+            dependencies: ["Fuzzilli"],
+            resources: [.copy("CompilerTests")]),
     ],
     swiftLanguageVersions: [.v5]
 )

Sources/FuzzILTool/main.swift

@@ -33,7 +33,7 @@ func loadProgram(from path: String) throws -> Program {
 
 func loadAllPrograms(in dirPath: String) -> [(filename: String, program: Program)] {
     var isDir: ObjCBool = false
-    if !FileManager.default.fileExists(atPath: dirPath, isDirectory:&isDir) || !isDir.boolValue {
+    if !FileManager.default.fileExists(atPath: dirPath, isDirectory: &isDir) || !isDir.boolValue {
         print("\(dirPath) is not a directory!")
         exit(-1)
     }
@@ -56,7 +56,7 @@ func loadAllPrograms(in dirPath: String) -> [(filename: String, program: Program
 }
 
 // Takes a program and lifts it to JavaScript.
-func liftToJS(_ jsLifter: JavaScriptLifter,_ prog: Program) -> String {
+func liftToJS(_ jsLifter: JavaScriptLifter, _ prog: Program) -> String {
     let res = jsLifter.lift(prog)
     return res.trimmingCharacters(in: .whitespacesAndNewlines)
 }
@@ -72,10 +72,13 @@ func liftToFuzzIL(_ prog: Program) -> String {
 func liftAllPrograms(in dirPath: String, with lifter: Lifter, fileExtension: String) -> Int {
     var numLiftedPrograms = 0
     for (filename, program) in loadAllPrograms(in: dirPath) {
-        let newFilePath = "\(dirPath)/\(filename.dropLast(protoBufFileExtension.count))\(fileExtension)"
+        let newFilePath =
+            "\(dirPath)/\(filename.dropLast(protoBufFileExtension.count))\(fileExtension)"
         let content = lifter.lift(program)
         do {
-            try content.write(to: URL(fileURLWithPath: newFilePath), atomically: false, encoding: String.Encoding.utf8)
+            try content.write(
+                to: URL(fileURLWithPath: newFilePath), atomically: false,
+                encoding: String.Encoding.utf8)
             numLiftedPrograms += 1
         } catch {
             print("Failed to write file \(newFilePath): \(error)")
@@ -96,29 +99,32 @@ func loadProgramOrExit(from path: String) -> Program {
 let args = Arguments.parse(from: CommandLine.arguments)
 
 if args["-h"] != nil || args["--help"] != nil || args.numPositionalArguments != 1 {
-    print("""
-          Usage:
-          \(args.programName) options path
-
-          Options:
-              --liftToFuzzIL           : Lifts the given protobuf program to FuzzIL's text format and prints it
-              --liftToJS               : Lifts the given protobuf program to JS and prints it
-              --liftCorpusToJS         : Loads all .fzil files in a directory and lifts them to .js files in that same directory
-              --dumpProtobuf           : Dumps the raw content of the given protobuf file
-              --dumpProgram            : Dumps the internal representation of the program stored in the given protobuf file
-              --checkCorpus            : Attempts to load all .fzil files in a directory and checks if they are statically valid
-              --compile                : Compile the given JavaScript program to a FuzzIL program. Requires node.js
-              --outputPathJS           : If given, --compile will write the lifted JS file to the given path after compilation.
-              --generate               : Generate a random program using Fuzzilli's code generators and save it to the specified path.
-              --forDifferentialFuzzing : Enable additional features for better support of external differential fuzzing.
-          """)
+    print(
+        """
+        Usage:
+        \(args.programName) options path
+
+        Options:
+            --liftToFuzzIL           : Lifts the given protobuf program to FuzzIL's text format and prints it
+            --liftToJS               : Lifts the given protobuf program to JS and prints it
+            --liftCorpusToJS         : Loads all .fzil files in a directory and lifts them to .js files in that same directory
+            --dumpProtobuf           : Dumps the raw content of the given protobuf file
+            --dumpProgram            : Dumps the internal representation of the program stored in the given protobuf file
+            --checkCorpus            : Attempts to load all .fzil files in a directory and checks if they are statically valid
+            --compile                : Compile the given JavaScript program to a FuzzIL program. Requires node.js
+            --outputPathJS           : If given, --compile will write the lifted JS file to the given path after compilation.
+            --generate               : Generate a random program using Fuzzilli's code generators and save it to the specified path.
+            --forDifferentialFuzzing : Enable additional features for better support of external differential fuzzing.
+        """)
     exit(0)
 }
 
 let path = args[0]
 
 let forDifferentialFuzzing = args.has("--forDifferentialFuzzing")
-let jsLifter = JavaScriptLifter(prefix: jsPrefix, suffix: jsSuffix, ecmaVersion: ECMAScriptVersion.es6, environment: JavaScriptEnvironment(), alwaysEmitVariables: forDifferentialFuzzing)
+let jsLifter = JavaScriptLifter(
+    prefix: jsPrefix, suffix: jsSuffix, ecmaVersion: ECMAScriptVersion.es6,
+    environment: JavaScriptEnvironment(), alwaysEmitVariables: forDifferentialFuzzing)
 
 // Covert a single IL protobuf file to FuzzIL's text format and print to stdout
 if args.has("--liftToFuzzIL") {
@@ -134,7 +140,8 @@ else if args.has("--liftToJS") {
 
 // Lift all protobuf programs to JavaScript
 else if args.has("--liftCorpusToJS") {
-    let numLiftedPrograms = liftAllPrograms(in: path, with: jsLifter, fileExtension: jsFileExtension)
+    let numLiftedPrograms = liftAllPrograms(
+        in: path, with: jsLifter, fileExtension: jsFileExtension)
     print("Lifted \(numLiftedPrograms) programs to JS")
 }
 
@@ -166,7 +173,9 @@ else if args.has("--compile") {
         exit(-1)
     }
     guard let parser = JavaScriptParser(executor: nodejs) else {
-        print("The JavaScript parser does not appear to be working. See Sources/Fuzzilli/Compiler/Parser/README.md for instructions on how to set it up.")
+        print(
+            "The JavaScript parser does not appear to be working. See Sources/Fuzzilli/Compiler/Parser/README.md for instructions on how to set it up."
+        )
         exit(-1)
     }
 
@@ -194,7 +203,9 @@ else if args.has("--compile") {
     if let js_path = args["--outputPathJS"] {
         let content = ast.leadingComments + jsLifter.lift(program)
         do {
-            try content.write(to: URL(fileURLWithPath: js_path), atomically: false, encoding: String.Encoding.utf8)
+            try content.write(
+                to: URL(fileURLWithPath: js_path), atomically: false, encoding: String.Encoding.utf8
+            )
         } catch {
             print("Failed to write file \(js_path): \(error)")
             exit(-1)
@@ -205,7 +216,8 @@ else if args.has("--compile") {
         print(jsLifter.lift(program))
 
         do {
-            let outputPath = URL(fileURLWithPath: path).deletingPathExtension().appendingPathExtension("fzil")
+            let outputPath = URL(fileURLWithPath: path).deletingPathExtension()
+                .appendingPathExtension("fzil")
             try program.asProtobuf().serializedData().write(to: outputPath)
             print("FuzzIL program written to \(outputPath.relativePath)")
         } catch {
@@ -216,7 +228,9 @@ else if args.has("--compile") {
 }
 
 else if args.has("--generate") {
-    let fuzzer = makeMockFuzzer(config: Configuration(logLevel: .warning, enableInspection: true), environment: JavaScriptEnvironment())
+    let fuzzer = makeMockFuzzer(
+        config: Configuration(logLevel: .warning, enableInspection: true),
+        environment: JavaScriptEnvironment())
     let b = fuzzer.makeBuilder()
     b.buildPrefix()
     b.build(n: 50, by: .generating)
@@ -225,7 +239,8 @@ else if args.has("--generate") {
     print(jsLifter.lift(program, withOptions: .includeComments))
 
     do {
-        let outputPath = URL(fileURLWithPath: path).deletingPathExtension().appendingPathExtension("fzil")
+        let outputPath = URL(fileURLWithPath: path).deletingPathExtension().appendingPathExtension(
+            "fzil")
         try program.asProtobuf().serializedData().write(to: outputPath)
     } catch {
         print("Failed to store output program to disk: \(error)")

Sources/Fuzzilli/Base/ContextGraph.swift

@@ -79,20 +79,25 @@ public class ContextGraph {
             for i in 1..<generator.parts.count {
                 let stub = generator.parts[i]
 
-                guard stub.requiredContext.matches(currentContext) ||
-                (stub.requiredContext.isJavascript && currentContext.isEmpty) ||
-                // If the requiredContext is more than two, we should never provide a context.
-                // See `CodeGenerator` for details.
-                (!stub.requiredContext.isSingle && currentContext.isEmpty) else {
+                guard
+                    stub.requiredContext.matches(currentContext)
+                        || (stub.requiredContext.isJavascript && currentContext.isEmpty)
+                        // If the requiredContext is more than two, we should never provide a context.
+                        // See `CodeGenerator` for details.
+                        || (!stub.requiredContext.isSingle && currentContext.isEmpty)
+                else {
                     fatalError("Inconsistent requires/provides Contexts for \(generator.name)")
                 }
 
-                currentContext = stub.providedContext.isEmpty ? currentContext : Context(stub.providedContext)
+                currentContext =
+                    stub.providedContext.isEmpty ? currentContext : Context(stub.providedContext)
             }
         }
     }
 
-    private func warnOfSuspiciousContexts(in generators: WeightedList<CodeGenerator>, withLogger logger: Logger) {
+    private func warnOfSuspiciousContexts(
+        in generators: WeightedList<CodeGenerator>, withLogger logger: Logger
+    ) {
         // Technically we don't need any generator to emit the .javascript context, as this is provided by the toplevel.
         var providedContexts = Set<Context>([.javascript])
         var requiredContexts = Set<Context>()
@@ -107,15 +112,19 @@ public class ContextGraph {
         for generator in generators {
             // Now check which generators don't have providers
             if !providedContexts.contains(generator.requiredContext) {
-                logger.warning("Generator \(generator.name) cannot be run as it doesn't have a Generator that can provide this context.")
+                logger.warning(
+                    "Generator \(generator.name) cannot be run as it doesn't have a Generator that can provide this context."
+                )
 
             }
 
             // All provided contexts must be required by some generator.
             if !generator.providedContexts.allSatisfy({
                 requiredContexts.contains($0)
             }) {
-                logger.warning("Generator \(generator.name) provides a context that is never required by another generator \(generator.providedContexts)")
+                logger.warning(
+                    "Generator \(generator.name) provides a context that is never required by another generator \(generator.providedContexts)"
+                )
             }
         }
     }
@@ -139,7 +148,8 @@ public class ContextGraph {
             }
 
             // Get all possible edges from here on and push all of those to the queue.
-            for edge in self.edges where edge.key.from == currentNode && !seenNodes.contains(edge.key.to) {
+            for edge in self.edges
+            where edge.key.from == currentNode && !seenNodes.contains(edge.key.to) {
                 // Prevent cycles, we don't care about complicated paths, but rather simple direct paths.
                 seenNodes.insert(edge.key.to)
                 queue.append(currentPath + [edge.key.to])
@@ -155,7 +165,7 @@ public class ContextGraph {
         for path in paths {
             var edgePath: [EdgeKey] = []
             for i in 0..<(path.count - 1) {
-                let edge = EdgeKey(from: path[i], to: path[i+1])
+                let edge = EdgeKey(from: path[i], to: path[i + 1])
                 edgePath.append(edge)
             }
             edgePaths.append(edgePath)
@@ -185,7 +195,8 @@ public class ContextGraph {
             var stillExploring = false
 
             // Get all possible edges from here on and push all of those to the queue.
-            for edge in self.edges where edge.key.from == currentNode && !seenNodes.contains(edge.key.to) {
+            for edge in self.edges
+            where edge.key.from == currentNode && !seenNodes.contains(edge.key.to) {
                 // Prevent cycles, we don't care about complicated paths, but rather simple direct paths.
                 stillExploring = true
                 seenNodes.insert(edge.key.to)
@@ -220,9 +231,10 @@ public class ContextGraph {
         }
 
         return paths.map { edges in
-            Path(edges: edges.map { edge in
-                self.edges[edge]!
-            })
+            Path(
+                edges: edges.map { edge in
+                    self.edges[edge]!
+                })
         }
     }
 }

Sources/Fuzzilli/Base/Contributor.swift

@@ -93,7 +93,8 @@ public class Contributor: Hashable {
     }
 
     public var totalSamples: Int {
-        return validSamples + interestingSamples + invalidSamples + timedOutSamples + crashingSamples + differentialSamples
+        return validSamples + interestingSamples + invalidSamples + timedOutSamples
+            + crashingSamples + differentialSamples
     }
 
     // If this is low, that means the CodeGenerator has dynamic requirements that are not met most of the time.