Merge pull request swiftlang#134 from benlangmuir/swiftpm-test

[test] Add a test for SwiftPM integration

Author: benlangmuir

Sources/SKTestSupport/SKSwiftPMTestWorkspace.swift

@@ -0,0 +1,174 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SourceKit
+import SKSwiftPMWorkspace
+import LanguageServerProtocol
+import SKCore
+import IndexStoreDB
+import ISDBTibs
+import ISDBTestSupport
+import Basic
+import SPMUtility
+import XCTest
+import Foundation
+
+public final class SKSwiftPMTestWorkspace {
+
+  /// The directory containing the original, unmodified project.
+  public let projectDir: URL
+
+  /// A test-specific directory that we can put temporary files into.
+  public let tmpDir: URL
+
+  /// The build directory.
+  public let buildDir: URL
+
+  /// The source files used by the test.
+  public let sources: TestSources
+
+  /// The source code index.
+  public var index: IndexStoreDB
+
+  /// The toolchain.
+  public let toolchain: Toolchain
+
+  /// Connection to the language server.
+  public let testServer: TestSourceKitServer = TestSourceKitServer(connectionKind: .local)
+
+  public var sk: TestClient { testServer.client }
+
+  public init(projectDir: URL, tmpDir: URL, toolchain: Toolchain) throws {
+    self.projectDir = projectDir
+    self.tmpDir = tmpDir
+    self.toolchain = toolchain
+
+    let fm = FileManager.default
+    _ = try? fm.removeItem(at: tmpDir)
+
+    buildDir = tmpDir.appendingPathComponent("build", isDirectory: true)
+    try fm.createDirectory(at: buildDir, withIntermediateDirectories: true, attributes: nil)
+    let sourceDir = tmpDir.appendingPathComponent("src", isDirectory: true)
+    try fm.copyItem(at: projectDir, to: sourceDir)
+    let databaseDir = tmpDir.appendingPathComponent("db", isDirectory: true)
+    try fm.createDirectory(at: databaseDir, withIntermediateDirectories: true, attributes: nil)
+
+    self.sources = try TestSources(rootDirectory: sourceDir)
+
+    let sourcePath = AbsolutePath(sources.rootDirectory.path)
+    let buildPath = AbsolutePath(buildDir.path)
+    let buildSetup = BuildSetup(configuration: .debug, path: buildPath, flags: BuildFlags())
+
+    let swiftpm = try SwiftPMWorkspace(
+      workspacePath: sourcePath,
+      toolchainRegistry: ToolchainRegistry.shared,
+      buildSetup: buildSetup)
+
+    let libIndexStore = try IndexStoreLibrary(dylibPath: toolchain.libIndexStore!.pathString)
+
+    try fm.createDirectory(atPath: swiftpm.indexStorePath!.pathString, withIntermediateDirectories: true)
+
+    self.index = try IndexStoreDB(
+      storePath: swiftpm.indexStorePath!.pathString,
+      databasePath: tmpDir.path,
+      library: libIndexStore,
+      listenToUnitEvents: false)
+
+    sk.allowUnexpectedNotification = true
+
+    testServer.server!.workspace = Workspace(
+      rootPath: sourcePath,
+      clientCapabilities: ClientCapabilities(),
+      buildSettings: swiftpm,
+      index: index,
+      buildSetup: buildSetup)
+  }
+
+  deinit {
+    _ = try? FileManager.default.removeItem(atPath: tmpDir.path)
+  }
+}
+
+extension SKSwiftPMTestWorkspace {
+
+  public func testLoc(_ name: String) -> TestLocation { sources.locations[name]! }
+
+  public func buildAndIndex() throws {
+    try build()
+    index.pollForUnitChangesAndWait()
+  }
+
+  public enum Error: Swift.Error {
+    case buildFailure(Foundation.Process.TerminationReason, exitCode: Int32)
+  }
+
+  func build() throws {
+    let p = Process()
+    p.launchPath = String(toolchain.swiftc!.pathString.dropLast())
+    p.arguments = [
+      "build",
+      "--package-path", sources.rootDirectory.path,
+      "--build-path", buildDir.path,
+      "-Xswiftc", "-index-ignore-system-modules",
+      "-Xcc", "-index-ignore-system-symbols",
+    ]
+
+    p.launch()
+    p.waitUntilExit()
+    if p.terminationReason != .exit || p.terminationStatus != 0 {
+      throw Error.buildFailure(p.terminationReason, exitCode: p.terminationStatus)
+    }
+  }
+}
+
+extension SKSwiftPMTestWorkspace {
+  public func openDocument(_ url: URL, language: Language) throws {
+    sk.send(DidOpenTextDocument(textDocument: TextDocumentItem(
+      url: url,
+      language: language,
+      version: 1,
+      text: try sources.sourceCache.get(url))))
+  }
+}
+
+extension XCTestCase {
+
+  public func staticSourceKitSwiftPMWorkspace(name: String, testFile: String = #file) throws -> SKSwiftPMTestWorkspace? {
+    let testDirName = testDirectoryName
+    let toolchain = ToolchainRegistry.shared.default!
+    let workspace = try SKSwiftPMTestWorkspace(
+      projectDir: inputsDirectory(testFile: testFile)
+        .appendingPathComponent(name, isDirectory: true),
+      tmpDir: URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+        .appendingPathComponent("sk-test-data/\(testDirName)", isDirectory: true),
+      toolchain: toolchain)
+
+    let hasClangFile: Bool = workspace.sources.locations.contains { _, loc in
+      loc.url.pathExtension != "swift"
+    }
+
+    if hasClangFile {
+      if toolchain.libIndexStore == nil {
+        fputs("warning: skipping test because libIndexStore is missing;" +
+              "install Clang's IndexStore component\n", stderr)
+        return nil
+      }
+      if !TibsToolchain(toolchain).clangHasIndexSupport {
+        fputs("warning: skipping test because '\(toolchain.clang!)' does not " +
+              "have indexstore support; use swift-clang\n", stderr)
+        return nil
+      }
+    }
+
+    return workspace
+  }
+}

Tests/INPUTS/SwiftPMPackage/Package.swift

@@ -0,0 +1,17 @@
+// swift-tools-version:5.1
+
+import PackageDescription
+
+let package = Package(
+  name: "SwiftPMPackage",
+  products: [],
+  dependencies: [],
+  targets: [
+    .target(
+      name: "exec",
+      dependencies: ["lib"]),
+    .target(
+      name: "lib",
+      dependencies: []),
+  ]
+)

Tests/INPUTS/SwiftPMPackage/Sources/exec/main.swift

@@ -0,0 +1,3 @@
+import lib
+
+Lib() . /*Lib.foo:call*/foo()

Tests/INPUTS/SwiftPMPackage/Sources/lib/lib.swift

@@ -0,0 +1,5 @@
+public struct Lib {
+  public func /*Lib.foo:def*/foo() {}
+
+  public init() {}
+}

Tests/SKSwiftPMWorkspaceTests/XCTestManifests.swift

@@ -15,6 +15,8 @@ extension SwiftPMWorkspaceTests {
         ("testMultiTargetSwift", testMultiTargetSwift),
         ("testNoPackage", testNoPackage),
         ("testNoToolchain", testNoToolchain),
+        ("testSymlinkInWorkspaceCXX", testSymlinkInWorkspaceCXX),
+        ("testSymlinkInWorkspaceSwift", testSymlinkInWorkspaceSwift),
         ("testUnknownFile", testUnknownFile),
         ("testUnparsablePackage", testUnparsablePackage),
     ]

Tests/SourceKitTests/SwiftPMIntegration.swift

@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+@testable import SourceKit
+import LanguageServerProtocol
+import SKTestSupport
+import XCTest
+
+final class SwiftPMIntegrationTests: XCTestCase {
+
+  func testSwiftPMIntegration() throws {
+    guard let ws = try staticSourceKitSwiftPMWorkspace(name: "SwiftPMPackage") else { return }
+    try ws.buildAndIndex()
+
+    let call = ws.testLoc("Lib.foo:call")
+    let def = ws.testLoc("Lib.foo:def")
+    try ws.openDocument(call.url, language: .swift)
+    let refs = try ws.sk.sendSync(ReferencesRequest(textDocument: call.docIdentifier, position: call.position))
+
+    XCTAssertEqual(Set(refs), [
+      Location(call),
+      Location(def),
+    ])
+
+    let completions = try ws.sk.sendSync(CompletionRequest(textDocument: call.docIdentifier, position: call.position))
+
+    XCTAssertEqual(completions, CompletionList(isIncomplete: false, items: [
+      CompletionItem(
+        label: "foo()",
+        detail: "Void",
+        sortText: nil,
+        filterText: "foo()",
+        textEdit: nil,
+        insertText: "foo()",
+        insertTextFormat: .plain,
+        kind: .method,
+        deprecated: nil),
+      CompletionItem(
+        label: "self",
+        detail: "Lib",
+        sortText: nil,
+        filterText: "self",
+        textEdit: nil,
+        insertText: "self",
+        insertTextFormat: .plain,
+        kind: .keyword,
+        deprecated: nil),
+    ]))
+  }
+}

Tests/SourceKitTests/XCTestManifests.swift

@@ -54,6 +54,7 @@ extension LocalClangTests {
     //   `swift test --generate-linuxmain`
     // to regenerate.
     static let __allTests__LocalClangTests = [
+        ("testClangStdHeaderCanary", testClangStdHeaderCanary),
         ("testFoldingRange", testFoldingRange),
         ("testSymbolInfo", testSymbolInfo),
     ]
@@ -98,6 +99,15 @@ extension SwiftCompletionTests {
     ]
 }
 
+extension SwiftPMIntegrationTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__SwiftPMIntegrationTests = [
+        ("testSwiftPMIntegration", testSwiftPMIntegration),
+    ]
+}
+
 public func __allTests() -> [XCTestCaseEntry] {
     return [
         testCase(CodeActionTests.__allTests__CodeActionTests),
@@ -108,6 +118,7 @@ public func __allTests() -> [XCTestCaseEntry] {
         testCase(LocalSwiftTests.__allTests__LocalSwiftTests),
         testCase(SKTests.__allTests__SKTests),
         testCase(SwiftCompletionTests.__allTests__SwiftCompletionTests),
+        testCase(SwiftPMIntegrationTests.__allTests__SwiftPMIntegrationTests),
     ]
 }
 #endif