Merge pull request swiftlang#51 from nkcsgexi/remove-atomic

Remove calls to stdlib private functions.

Author: nkcsgexi

Sources/SwiftSyntax/AtomicCache.swift

@@ -0,0 +1,43 @@
+//===--------------------- LazyNonThreadSafeCache.swift -------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 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 Foundation
+
+/// LazyNonThreadSafeCache is a wrapper class around an uninitialized value.
+/// It takes a closure that will be used to create the value when needed.
+///
+/// FIXME: the cache is no longer thread-safe. We need stdlib to provide proper
+/// APIs to ensure thread safety
+class LazyNonThreadSafeCache<Value: AnyObject> {
+  /// The cached pointer that will be filled in the first time `value` is
+  /// accessed.
+  private var _cachedValue: AnyObject?
+
+  /// The value inside this cache. If the value has not been initialized when
+  /// this value is requested, then the closure will be called and its resulting
+  /// value will be stored in the cache.
+  /// - Parameter create: The closure that will return the fully realized value
+  ///                     inside the cache.
+  func value(_ create: () -> Value) -> Value {
+    if _cachedValue == nil {
+      _cachedValue = create()
+    }
+    return _cachedValue as! Value
+  }
+
+  /// Get the raw cache with the right type for debugging purposes.
+  /// - note: Only for use in the debugger!
+  @available(*, deprecated, message: "Only for use in the debugger.")
+  var unsafeValue: Value? {
+    return _cachedValue as? Value
+  }
+}

Sources/SwiftSyntax/LazyNonThreadSafeCache.swift

@@ -93,7 +93,7 @@ final class RawSyntax {
   /// incremental parses
   let id: SyntaxNodeId
 
-  var _contentLength = AtomicCache<Box<SourceLength>>()
+  var _contentLength = LazyNonThreadSafeCache<Box<SourceLength>>()
 
   /// The length of this node excluding its leading and trailing trivia
   var contentLength: SourceLength {

Sources/SwiftSyntax/RawSyntax.swift

@@ -36,9 +36,9 @@ final class SyntaxData: Equatable {
   let indexInParent: Int
   weak var parent: SyntaxData?
 
-  let childCaches: [AtomicCache<SyntaxData>]
+  let childCaches: [LazyNonThreadSafeCache<SyntaxData>]
 
-  private let positionCache: AtomicCache<Box<AbsolutePosition>>
+  private let positionCache: LazyNonThreadSafeCache<Box<AbsolutePosition>>
 
   fileprivate func calculatePosition() -> AbsolutePosition {
     guard let parent = parent else {
@@ -92,8 +92,8 @@ final class SyntaxData: Equatable {
     self.raw = raw
     self.indexInParent = indexInParent
     self.parent = parent
-    self.childCaches = raw.layout.map { _ in AtomicCache<SyntaxData>() }
-    self.positionCache = AtomicCache<Box<AbsolutePosition>>()
+    self.childCaches = raw.layout.map { _ in LazyNonThreadSafeCache<SyntaxData>() }
+    self.positionCache = LazyNonThreadSafeCache<Box<AbsolutePosition>>()
   }
 
   /// The index path from this node to the root. This can be used to uniquely

Sources/SwiftSyntax/SyntaxData.swift

@@ -66,6 +66,7 @@ public protocol ${node.name}: Syntax {}
 %     for line in dedented_lines(node.description):
 /// ${line}
 %     end
+/// Syntax nodes are not thread-safe.
 public struct ${node.name}: ${base_type}, _SyntaxBase, Hashable {
 %     if node.children:
   enum Cursor: Int {

Sources/SwiftSyntax/SyntaxNodes.swift.gyb

@@ -6,7 +6,8 @@ XCTMain({ () -> [XCTestCaseEntry] in
     testCase(AbsolutePositionTestCase.allTests),
     testCase(DecodeSyntaxTestCase.allTests),
     testCase(DiagnosticTestCase.allTests),
-    testCase(LazyCachingTestCase.allTests),
+    // We need to make syntax node thread safe to enable these tests
+    // testCase(LazyCachingTestCase.allTests),
     testCase(ParseFileTestCase.allTests),
     testCase(SyntaxChildrenAPITestCase.allTests),
     testCase(SyntaxCollectionsAPITestCase.allTests),

Tests/LinuxMain.swift

@@ -4,19 +4,21 @@ import SwiftSyntax
 public class LazyCachingTestCase: XCTestCase {
 
   public static let allTests = [
-    ("testPathological", testPathological),
-    ("testTwoAccesses", testTwoAccesses),
+    ("testPathological", disabledtestPathological),
+    ("testTwoAccesses", disabledtestTwoAccesses),
   ]
 
-  public func testPathological() {
+  // FIXME: re-enable this test when syntax nodes are thread safe
+  public func disabledtestPathological() {
     let tuple = SyntaxFactory.makeVoidTupleType()
 
     DispatchQueue.concurrentPerform(iterations: 100) { _ in
       XCTAssertEqual(tuple.leftParen, tuple.leftParen)
     }
   }
 
-  public func testTwoAccesses() {
+  // FIXME: re-enable this test when syntax nodes are thread safe
+  public func disabledtestTwoAccesses() {
     let tuple = SyntaxFactory.makeVoidTupleType()
 
     let queue1 = DispatchQueue(label: "queue1")