[incrParse] Add test cases to test the incremental syntax tree transfer

Author: ahoppen

cmake/modules/AddSwift.cmake

@@ -2022,7 +2022,7 @@ function(_add_swift_executable_single name)
   cmake_parse_arguments(SWIFTEXE_SINGLE
     "EXCLUDE_FROM_ALL;DONT_STRIP_NON_MAIN_SYMBOLS;DISABLE_ASLR"
     "SDK;ARCHITECTURE"
-    "DEPENDS;LLVM_COMPONENT_DEPENDS;LINK_LIBRARIES;LINK_FAT_LIBRARIES"
+    "DEPENDS;LLVM_COMPONENT_DEPENDS;LINK_LIBRARIES;LINK_FAT_LIBRARIES;COMPILE_FLAGS"
     ${ARGN})
 
   set(SWIFTEXE_SINGLE_SOURCES ${SWIFTEXE_SINGLE_UNPARSED_ARGUMENTS})
@@ -2096,6 +2096,7 @@ function(_add_swift_executable_single name)
       MODULE_NAME ${name}
       SDK ${SWIFTEXE_SINGLE_SDK}
       ARCHITECTURE ${SWIFTEXE_SINGLE_ARCHITECTURE}
+      COMPILE_FLAGS ${SWIFTEXE_SINGLE_COMPILE_FLAGS}
       IS_MAIN)
   add_swift_source_group("${SWIFTEXE_SINGLE_EXTERNAL_SOURCES}")
 
@@ -2260,7 +2261,7 @@ function(add_swift_executable name)
   cmake_parse_arguments(SWIFTEXE
     "EXCLUDE_FROM_ALL;DONT_STRIP_NON_MAIN_SYMBOLS;DISABLE_ASLR"
     ""
-    "DEPENDS;LLVM_COMPONENT_DEPENDS;LINK_LIBRARIES"
+    "DEPENDS;LLVM_COMPONENT_DEPENDS;LINK_LIBRARIES;COMPILE_FLAGS"
     ${ARGN})
 
   translate_flag(${SWIFTEXE_EXCLUDE_FROM_ALL}
@@ -2283,6 +2284,7 @@ function(add_swift_executable name)
       LINK_LIBRARIES ${SWIFTEXE_LINK_LIBRARIES}
       SDK ${SWIFT_HOST_VARIANT_SDK}
       ARCHITECTURE ${SWIFT_HOST_VARIANT_ARCH}
+      COMPILE_FLAGS ${SWIFTEXE_COMPILE_FLAGS}
       ${SWIFTEXE_EXCLUDE_FROM_ALL_FLAG}
       ${SWIFTEXE_DONT_STRIP_NON_MAIN_SYMBOLS_FLAG}
       ${SWIFTEXE_DISABLE_ASLR_FLAG})
@@ -2301,11 +2303,16 @@ function(add_swift_host_tool executable)
       ADDSWIFTHOSTTOOL # prefix
       "" # options
       "" # single-value args
-      "SWIFT_COMPONENT" # multi-value args
+      "SWIFT_COMPONENT;COMPILE_FLAGS;DEPENDS" # multi-value args
       ${ARGN})
 
   # Create the executable rule.
-  add_swift_executable(${executable} ${ADDSWIFTHOSTTOOL_UNPARSED_ARGUMENTS})
+  add_swift_executable(
+    ${executable} 
+    ${ADDSWIFTHOSTTOOL_UNPARSED_ARGUMENTS}
+    DEPENDS ${ADDSWIFTHOSTTOOL_DEPENDS}
+    COMPILE_FLAGS ${ADDSWIFTHOSTTOOL_COMPILE_FLAGS}
+  )
 
   # And then create the install rule if we are asked to.
   if (ADDSWIFTHOSTTOOL_SWIFT_COMPONENT)

test/incrParse/simple.swift

@@ -13,6 +13,16 @@
 // RUN: %validate-incrparse %s --test-case LAST_CHARACTER_OF_STRUCT
 // RUN: %validate-incrparse %s --test-case ADD_ARRAY_CLOSE_BRACKET
 // RUN: %validate-incrparse %s --test-case ADD_IF_OPEN_BRACE
+// We need to require macOS since %incr-transfer-roundtrip uses swiftSyntax
+// which is not available on Linux
+// FIXME: Remove the requires flag when swiftSyntax builds on Linux
+// REQUIRES: OS=macosx
+// RUN: %incr-transfer-roundtrip %s --test-case REPLACE
+// RUN: %incr-transfer-roundtrip %s --test-case INSERT
+// RUN: %incr-transfer-roundtrip %s --test-case REMOVE
+// RUN: %incr-transfer-roundtrip %s --test-case CLASS_SURROUNDING
+// RUN: %incr-transfer-roundtrip %s --test-case MULTI_EDIT
+// RUN: %incr-transfer-roundtrip %s --test-case REPLACE_WITH_MULTI_BYTE_CHAR
 
 func start() {}
 

test/lit.cfg

@@ -256,6 +256,7 @@ config.sil_passpipeline_dumper = inferSwiftBinary('sil-passpipeline-dumper')
 config.lldb_moduleimport_test = inferSwiftBinary('lldb-moduleimport-test')
 config.swift_ide_test = inferSwiftBinary('swift-ide-test')
 config.swift_syntax_test = inferSwiftBinary('swift-syntax-test')
+config.swift_swiftsyntax_test = inferSwiftBinary('swift-swiftsyntax-test')
 config.swift_reflection_dump = inferSwiftBinary('swift-reflection-dump')
 config.swift_remoteast_test = inferSwiftBinary('swift-remoteast-test')
 config.swift_format = inferSwiftBinary('swift-format')
@@ -345,6 +346,7 @@ ccp_opt = "-completion-cache-path %r" % completion_cache_path
 lit_config.note("Using code completion cache: " + completion_cache_path)
 
 config.substitutions.append( ('%validate-incrparse', '%utils/incrparse/validate_parse.py --temp-dir %t --swift-syntax-test %swift-syntax-test') )
+config.substitutions.append( ('%incr-transfer-roundtrip', '%%utils/incrparse/incr_transfer_round_trip.py --temp-dir %%t --swift-syntax-test %%swift-syntax-test --swift-swiftsyntax-test %r' % (config.swift_swiftsyntax_test)) )
 config.substitutions.append( ('%swift_obj_root', config.swift_obj_root) )
 config.substitutions.append( ('%swift_src_root', config.swift_src_root) )
 config.substitutions.append( ('%{python}', sys.executable) )

tools/SwiftSyntax/CMakeLists.txt

@@ -28,8 +28,3 @@ add_swift_library(swiftSwiftSyntax SHARED
   INSTALL_IN_COMPONENT swift-syntax
   TARGET_SDKS OSX
   IS_STDLIB)
-
-add_custom_target(swiftSwiftSyntax
-    DEPENDS swiftSwiftSyntax-macosx
-      swiftSwiftSyntax-macosx-x86_64
-      swiftSwiftSyntax-swiftmodule-macosx-x86_64)

tools/swift-swiftsyntax-test/CMakeLists.txt

@@ -1,8 +1,9 @@
-set(SWIFT_SYNTAX_PATH "${SWIFT_LIBRARY_OUTPUT_INTDIR}/swift/macosx/x86_64")
-set(EXTRA_COMPILE_FLAGS "-I" "${SWIFT_SYNTAX_PATH}")
-set(EXTRA_LINKER_FLAGS "-Xlinker" "-rpath" "-Xlinker" "${SWIFT_SYNTAX_PATH}")
-
 add_swift_host_tool(swift-swiftsyntax-test
-  swift-syntax-test.swift
-  DEPENDS swiftSwiftSyntax
+  main.swift
+  CommandLineArguments.swift 
+  COMPILE_FLAGS "-module-name" "main"
+  DEPENDS 
+    swiftSwiftSyntax-macosx
+    swiftSwiftSyntax-macosx-x86_64
+    swiftSwiftSyntax-swiftmodule-macosx-x86_64
 )

tools/swift-swiftsyntax-test/CommandLineArguments.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+struct CommandLineArguments {
+  struct MissingArgumentError: LocalizedError {
+    let argName: String
+
+    var errorDescription: String? {
+      return "Missing required argument: \(argName)"
+    }
+  }
+  struct UnkeyedArgumentError: LocalizedError {
+    let argName: String
+
+    var errorDescription: String? {
+      return "Unexpectedly found command line argument \(argName) without a key"
+    }
+  }
+
+  private let args: [String: String]
+
+  static func parse<T: Sequence>(_ args: T) throws -> CommandLineArguments
+    where T.Element == String {
+      var parsedArgs: [String: String] = [:]
+      var currentKey: String? = nil
+      for arg in args {
+        if arg.hasPrefix("--") {
+          // Parse a new key
+          if let currentKey = currentKey {
+            // The last key didn't have a value. Just add it with an empty string as
+            // the value to the parsed args
+            parsedArgs[currentKey] = ""
+          }
+          currentKey = arg
+        } else {
+          if let currentKey = currentKey {
+            parsedArgs[currentKey] = arg
+          } else {
+            throw UnkeyedArgumentError(argName: arg)
+          }
+          currentKey = nil
+        }
+      }
+      if let currentKey = currentKey {
+        // The last key didn't have a value. Just add it with an empty string as
+        // the value to the parsed args
+        parsedArgs[currentKey] = ""
+      }
+      return CommandLineArguments(args: parsedArgs)
+  }
+
+  subscript(key: String) -> String? {
+    return args[key]
+  }
+
+  func getRequired(_ key: String) throws -> String {
+    if let value = args[key] {
+      return value
+    } else {
+      throw MissingArgumentError(argName: key)
+    }
+  }
+
+  func has(_ key: String) -> Bool {
+    return args[key] != nil
+  }
+}

tools/swift-swiftsyntax-test/main.swift

@@ -0,0 +1,70 @@
+import SwiftSyntax
+import Foundation
+
+/// Print the given message to stderr
+func printerr(_ message: String, terminator: String = "\n") {
+  FileHandle.standardError.write((message + terminator).data(using: .utf8)!)
+}
+
+/// Print the help message
+func printHelp() {
+  print("""
+    Utility to test SwiftSyntax syntax tree deserialization.
+
+    Actions (must specify one):
+      --deserialize-incremental
+            Deserialize a full pre-edit syntax tree (--pre-edit-tree), parse an
+            incrementally transferred post-edit syntax tree (--incr-tree) and
+            write the source representation of the post-edit syntax tree to an
+            out file (--out).
+      --help
+            Print this help message
+
+    Arguments:
+      --pre-edit-tree FILENAME
+            The path to a JSON serialized pre-edit syntax tree
+      --incr-tree FILENAME
+            The path to a JSON serialized incrementally transferred post-edit
+            syntax tree
+      --out FILENAME
+            The file to which the source representation of the post-edit syntax
+            tree shall be written.
+    """)
+}
+
+func performRoundTrip(args: CommandLineArguments) throws {
+  let preEditTreeURL = URL(fileURLWithPath: try args.getRequired("--pre-edit-tree"))
+  let incrTreeURL = URL(fileURLWithPath: try args.getRequired("--incr-tree"))
+  let outURL = URL(fileURLWithPath: try args.getRequired("--out"))
+
+  let preEditTreeData = try Data(contentsOf: preEditTreeURL)
+  let incrTreeData = try Data(contentsOf: incrTreeURL)
+
+  let deserializer = SyntaxTreeDeserializer()
+  _ = try deserializer.deserialize(preEditTreeData)
+  let tree = try deserializer.deserialize(incrTreeData)
+  let sourceRepresenation = tree.description
+  try sourceRepresenation.write(to: outURL, atomically: false, encoding: .utf8)
+}
+
+do {
+  let args = try CommandLineArguments.parse(CommandLine.arguments.dropFirst())
+
+  if args.has("--deserialize-incremental") {
+    try performRoundTrip(args: args)
+    exit(0)
+  } else if args.has("--help") {
+    printHelp()
+    exit(0)
+  } else {
+    printerr("""
+      No action specified.
+      See --help for information about available actions
+      """)
+    exit(1)
+  }
+} catch {
+  printerr(error.localizedDescription)
+  printerr("Run swift-swiftsyntax-test --help for more help.")
+  exit(1)
+}

tools/swift-swiftsyntax-test/swift-syntax-test.swift

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+import argparse
+import os
+import subprocess
+import sys
+
+from test_util import TestFailedError, serializeIncrParseMarkupFile
+
+
+def escapeCmdArg(arg):
+    if '"' in arg or ' ' in arg:
+        return '"%s"' % arg.replace('"', '\\"')
+    else:
+        return arg
+
+
+def run_command(cmd):
+    print(' '.join([escapeCmdArg(arg) for arg in cmd]))
+    return subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description='Utility for testing incremental syntax parsing',
+        epilog='''
+    Based of a single template the utility generates a pre-edit and a post-edit 
+    file. It then verifies that incrementally parsing the post-edit file base 
+    on the pre-edit file results in the same syntax tree as reparsing the 
+    post-edit file from scratch.
+
+    To generate the pre-edit and the post-edit file from the template, it 
+    operates on markers of the form:
+
+        <<test_case<pre|||post>>>
+
+    These placeholders are replaced by:
+      - 'pre' if a different test case than 'test_case' is run
+      - 'pre' for the pre-edit version of 'test_case'
+      - 'post' for the post-edit version of 'test_case'
+    ''')
+    parser.add_argument(
+        'file', type=argparse.FileType(),
+        help='The template file to test')
+    parser.add_argument(
+        '--test-case', default='',
+        help='The test case to execute. If no test case is specified all \
+              unnamed substitutions are applied')
+    parser.add_argument(
+        '--temp-dir', required=True,
+        help='A temporary directory where pre-edit and post-edit files can be \
+              saved')
+    parser.add_argument(
+        '--swift-syntax-test', required=True,
+        help='The path to swift-syntax-test')
+    parser.add_argument(
+        '--swift-swiftsyntax-test', required=True,
+        help='The path to swift-swiftsyntax-test')
+
+    args = parser.parse_args(sys.argv[1:])
+
+    test_file = args.file.name
+    test_file_name = os.path.basename(test_file)
+    test_case = args.test_case
+    temp_dir = args.temp_dir
+    swift_syntax_test = args.swift_syntax_test
+    swift_swiftsyntax_test = args.swift_swiftsyntax_test
+
+    if not os.path.exists(temp_dir):
+        os.makedirs(temp_dir)
+
+    pre_edit_tree_file = temp_dir + '/' + test_file_name + '.' \
+        + test_case + '.pre.json'
+    incremental_tree_file = temp_dir + '/' + test_file_name + '.' \
+        + test_case + '.incr.json'
+    post_edit_source_file = temp_dir + '/' + test_file_name + '.' \
+        + test_case + '.post.swift'
+    after_roundtrip_source_file = temp_dir + '/' + test_file_name + '.' \
+        + test_case + '.post_after_roundtrip.swift'
+
+    # Generate the syntax tree once incrementally and once from scratch
+    try:
+        serializeIncrParseMarkupFile(test_file=test_file, 
+                                     test_case=test_case, 
+                                     mode='pre-edit', 
+                                     serialization_mode='full',
+                                     omit_node_ids=False,
+                                     output_file=pre_edit_tree_file, 
+                                     temp_dir=temp_dir, 
+                                     swift_syntax_test=swift_syntax_test, 
+                                     print_visual_reuse_info=False)
+
+        serializeIncrParseMarkupFile(test_file=test_file, 
+                                     test_case=test_case, 
+                                     mode='incremental', 
+                                     serialization_mode='incremental',
+                                     omit_node_ids=False,
+                                     output_file=incremental_tree_file, 
+                                     temp_dir=temp_dir, 
+                                     swift_syntax_test=swift_syntax_test, 
+                                     print_visual_reuse_info=False)
+    except TestFailedError as e:
+        print('Test case "%s" of %s FAILed' % (test_case, test_file), 
+              file=sys.stderr)
+        print(e.message, file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        run_command([swift_swiftsyntax_test, '--deserialize-incremental'] + 
+                    ['--pre-edit-tree', pre_edit_tree_file] +
+                    ['--incr-tree', incremental_tree_file] + 
+                    ['--out', after_roundtrip_source_file])
+    except subprocess.CalledProcessError as e:
+        print('Test case "%s" of %s FAILed' % (test_case, test_file), 
+              file=sys.stderr)
+        print('Deserializing the swift file failed:\n', file=sys.stderr)
+        print(e.output, file=sys.stderr)
+        sys.exit(1)
+
+    # Check if the two syntax trees are the same
+    try:
+        run_command(
+            [
+                'diff', '-u',
+                post_edit_source_file,
+                after_roundtrip_source_file
+            ])
+    except subprocess.CalledProcessError as e:
+        print('Test case "%s" of %s FAILed' % (test_case, test_file), 
+              file=sys.stderr)
+        print('Source file after incrementally transferring the syntax tree '
+              'to swiftSyntax does not match post-edit source file:\n\n', 
+              file=sys.stderr)
+        print(e.output, file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()