Preserve leading comments when transpiling JS

JS files often contain meta data in leading comments. We require these
comments to be able to execute JS code again after transpiling it
with the FuzzILTool.

This preserves such comments, whenever the `--outputPathJS` option
is used. The comments are extracted using information from the Babel
AST in the parser.

Bug: 442444727
Change-Id: Ibc9fda5f99a69123672b75970f9b5801c2695074
Reviewed-on: https://chrome-internal-review.googlesource.com/c/v8/fuzzilli/+/8839676
Reviewed-by: Matthias Liedtke <[email protected]>
Commit-Queue: Michael Achenbach <[email protected]>

Author: mi-ac

Sources/FuzzILTool/main.swift

@@ -188,7 +188,7 @@ else if args.has("--compile") {
     }
 
     if let js_path = args["--outputPathJS"] {
-        let content = jsLifter.lift(program)
+        let content = ast.leadingComments + jsLifter.lift(program)
         do {
             try content.write(to: URL(fileURLWithPath: js_path), atomically: false, encoding: String.Encoding.utf8)
         } catch {

Sources/Fuzzilli/Compiler/Parser/parser.js

@@ -36,6 +36,17 @@ function tryReadFile(path) {
 function parse(script, proto) {
     let ast = Parser.parse(script, { plugins: ["explicitResourceManagement", "v8intrinsic"] });
 
+    // We assume leading comments (and whitespace) until the starting
+    // character of the first node of the program. This way
+    // is easier than rebuilding the comments from Babel's
+    // `leadingComments` AST nodes, which don't include whitespace and
+    // newlines.
+    const firstNode = ast.program.body[0];
+    let leadingComments = '';
+    if (firstNode) {
+        leadingComments = script.substring(0, firstNode.start);
+    }
+
     function assertNoError(err) {
         if (err) throw err;
     }
@@ -46,7 +57,7 @@ function parse(script, proto) {
 
     function visitProgram(node) {
         const AST = proto.lookupType('compiler.protobuf.AST');
-        let program = {statements: []};
+        let program = {leadingComments: leadingComments, statements: []};
         for (let child of node.body) {
             program.statements.push(visitStatement(child));
         }
@@ -667,7 +678,7 @@ protobuf.load(astProtobufDefinitionPath, function(err, root) {
     if (err)
         throw err;
 
-    let ast = parse(script, root);
+    const ast = parse(script, root);
 
     // Uncomment this to print the AST to stdout (will be very verbose).
     //console.log(JSON.stringify(ast, null, 2));

Sources/Fuzzilli/Protobuf/ast.pb.swift

@@ -153,6 +153,8 @@ public struct Compiler_Protobuf_AST: Sendable {
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
 
+  public var leadingComments: String = String()
+
   public var statements: [Compiler_Protobuf_Statement] = []
 
   public var unknownFields = SwiftProtobuf.UnknownStorage()
@@ -2455,28 +2457,33 @@ extension Compiler_Protobuf_FunctionType: SwiftProtobuf._ProtoNameProviding {
 
 extension Compiler_Protobuf_AST: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   public static let protoMessageName: String = _protobuf_package + ".AST"
-  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}statements\0")
+  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}leadingComments\0\u{1}statements\0")
 
   public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
     while let fieldNumber = try decoder.nextFieldNumber() {
       // The use of inline closures is to circumvent an issue where the compiler
       // allocates stack space for every case branch when no optimizations are
       // enabled. https://github.com/apple/swift-protobuf/issues/1034
       switch fieldNumber {
-      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.statements) }()
+      case 1: try { try decoder.decodeSingularStringField(value: &self.leadingComments) }()
+      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.statements) }()
       default: break
       }
     }
   }
 
   public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.leadingComments.isEmpty {
+      try visitor.visitSingularStringField(value: self.leadingComments, fieldNumber: 1)
+    }
     if !self.statements.isEmpty {
-      try visitor.visitRepeatedMessageField(value: self.statements, fieldNumber: 1)
+      try visitor.visitRepeatedMessageField(value: self.statements, fieldNumber: 2)
     }
     try unknownFields.traverse(visitor: &visitor)
   }
 
   public static func ==(lhs: Compiler_Protobuf_AST, rhs: Compiler_Protobuf_AST) -> Bool {
+    if lhs.leadingComments != rhs.leadingComments {return false}
     if lhs.statements != rhs.statements {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true

Sources/Fuzzilli/Protobuf/ast.proto

@@ -16,7 +16,8 @@ syntax = "proto3";
 package compiler.protobuf;
 
 message AST {
-    repeated Statement statements = 1;
+    string leadingComments = 1;
+    repeated Statement statements = 2;
 }
 
 // A parameter in a function declaration. Not an expression on its own.