let package = Package(     .macOS(.v10_13)   ],   products: [-    .executable(name: "SwiftInspector", targets: ["SwiftInspector"]),+    .executable(name: "swift-inspector", targets: ["SwiftInspector"]),

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - PropertyAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds property information for the provided type in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeProperties? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeProperties?+    let visitor = TypeSyntaxVisitor(typeName: typeName) { [unowned self] typeProperties in+      guard self.typeName == typeProperties.name else { return }+      result = try? typeProperties.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(typeName: String, onNodeVisit: @escaping (_ info: TypeProperties) -> Void) {+    self.onNodeVisit = onNodeVisit+    self.typeName = typeName+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if+      let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self),+      typeIdentifier.name.text == typeName+    {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeProperties) -> Void+  private let typeName: String++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeProperties.PropertyData]()+    let propertyVisitor = PropertySyntaxVisitor(typeName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(typeName: String, onNodeVisit: @escaping (_ info: TypeProperties.PropertyData) -> Void) {+    self.typeName = typeName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    let modifier = findModifiers(from: node)++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+    }++    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            modifiers: modifier))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // e.g.:+        // public let thing: String = "Hello" has a type annotation, String which makes this easy+        // public let thing = "Hello" does not have a type annotation, and I don't know how to handle this case.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          modifiers: modifier))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let typeName: String+  private let onNodeVisit: (_ info: TypeProperties.PropertyData) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }++  private func findModifiers(from node: VariableDeclSyntax) -> TypeProperties.Modifier {+    let modifiersString: [String] = node.children+      .compactMap { $0.as(ModifierListSyntax.self) }+      .reduce(into: []) { result, syntax in+        let modifiers: [String] = syntax.children+          .compactMap { $0.as(DeclModifierSyntax.self) }+          .map { modifierSyntax in+            if+              let leftParen = modifierSyntax.detailLeftParen,+              let detail = modifierSyntax.detail,+              let rightParen = modifierSyntax.detailRightParen+            {+              return modifierSyntax.name.text + leftParen.text + detail.text + rightParen.text+            }+            return modifierSyntax.name.text+        }+        result.append(contentsOf: modifiers)+      }++    var modifier = modifiersString.reduce(TypeProperties.Modifier()) { result, stringValue in+      let modifier = TypeProperties.Modifier(stringValue: stringValue)+      return result.union(modifier)+    }++    // If there are no explicit modifiers, this is an internal property+    if !modifier.contains(.public) &&+      !modifier.contains(.fileprivate) &&+      !modifier.contains(.private)+    {+      modifier = modifier.union(.internal)+    }++    // If the variable isn't static, it's an instance variable+    if !modifier.contains(.static) {+      modifier = modifier.union(.instance)+    }++    return modifier+  }+}++// MARK: - TypeProperties++/// Information about a type as well as its associated properties+public struct TypeProperties: Hashable {++  public struct Modifier: Hashable, OptionSet {+    public let rawValue: Int++    public static let `internal` = Modifier(rawValue: 1 << 0)+    public static let `public` = Modifier(rawValue: 1 << 1)+    public static let `private` = Modifier(rawValue: 1 << 2)+    public static let privateSet = Modifier(rawValue: 1 << 3)+    public static let `fileprivate` = Modifier(rawValue: 1 << 4)+    public static let `instance` = Modifier(rawValue: 1 << 5)+    public static let `static` = Modifier(rawValue: 1 << 6)++    public init(rawValue: Int)  {+      self.rawValue = rawValue+    }++    public init(stringValue: String) {+      switch stringValue {+      case "public": self = .public+      case "private": self = .private+      case "private(set)": self = .privateSet+      case "fileprivate": self = .fileprivate+      case "internal": self = .internal+      case "static": self = .static+      default: self = []+      }+    }+  }++  public struct PropertyData: Hashable {+    /// The name of the property+    public let name: String+    /// The Type annotation of the property if it's present+    public let typeAnnotation: String?+    /// Any comments associated with the property+    public let comment: String+    /// Modifier set for this type+    public let modifiers: Modifier+  }++  /// The name of the type.+  public let name: String+  /// The properties on this type+  public let properties: [PropertyData]+}++extension TypeProperties {+  struct MergeError: Error, CustomStringConvertible {++    init(errorMessage: String) {+      self.errorMessage = errorMessage+    }++    var description: String { errorMessage }++    private let errorMessage: String+  }+}++extension TypeProperties.MergeError {+  static var invalidNames = TypeProperties.MergeError(+    errorMessage: "Invalid types - the type names must match to be merged.")+}++extension TypeProperties {+  func merge(with other: TypeProperties?) throws -> TypeProperties {+    guard let other = other else {+      return self+    }+    guard name == other.name else {+      throw MergeError.invalidNames+    }+    return TypeProperties(+      name: name,+      properties: Array(Set(properties).union(Set(other.properties))))+  }+}++extension TypeProperties.Modifier: CustomStringConvertible, CustomDebugStringConvertible {

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - PropertyAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds property information for the provided type in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeProperties? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeProperties?+    let visitor = TypeSyntaxVisitor(typeName: typeName) { [unowned self] typeProperties in+      guard self.typeName == typeProperties.name else { return }+      result = try? typeProperties.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(typeName: String, onNodeVisit: @escaping (_ info: TypeProperties) -> Void) {+    self.onNodeVisit = onNodeVisit+    self.typeName = typeName+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if+      let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self),+      typeIdentifier.name.text == typeName+    {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeProperties) -> Void+  private let typeName: String++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeProperties.PropertyData]()+    let propertyVisitor = PropertySyntaxVisitor(typeName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(typeName: String, onNodeVisit: @escaping (_ info: TypeProperties.PropertyData) -> Void) {+    self.typeName = typeName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    let modifier = findModifiers(from: node)++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+    }++    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            modifiers: modifier))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // e.g.:+        // public let thing: String = "Hello" has a type annotation, String which makes this easy+        // public let thing = "Hello" does not have a type annotation, and I don't know how to handle this case.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          modifiers: modifier))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let typeName: String+  private let onNodeVisit: (_ info: TypeProperties.PropertyData) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }++  private func findModifiers(from node: VariableDeclSyntax) -> TypeProperties.Modifier {+    let modifiersString: [String] = node.children+      .compactMap { $0.as(ModifierListSyntax.self) }+      .reduce(into: []) { result, syntax in+        let modifiers: [String] = syntax.children+          .compactMap { $0.as(DeclModifierSyntax.self) }+          .map { modifierSyntax in+            if+              let leftParen = modifierSyntax.detailLeftParen,+              let detail = modifierSyntax.detail,+              let rightParen = modifierSyntax.detailRightParen+            {+              return modifierSyntax.name.text + leftParen.text + detail.text + rightParen.text+            }+            return modifierSyntax.name.text+        }+        result.append(contentsOf: modifiers)+      }++    var modifier = modifiersString.reduce(TypeProperties.Modifier()) { result, stringValue in+      let modifier = TypeProperties.Modifier(stringValue: stringValue)+      return result.union(modifier)+    }++    // If there are no explicit modifiers, this is an internal property+    if !modifier.contains(.public) &&+      !modifier.contains(.fileprivate) &&+      !modifier.contains(.private)+    {+      modifier = modifier.union(.internal)+    }++    // If the variable isn't static, it's an instance variable+    if !modifier.contains(.static) {+      modifier = modifier.union(.instance)+    }++    return modifier+  }+}++// MARK: - TypeProperties++/// Information about a type as well as its associated properties+public struct TypeProperties: Hashable {++  public struct Modifier: Hashable, OptionSet {+    public let rawValue: Int++    public static let `internal` = Modifier(rawValue: 1 << 0)+    public static let `public` = Modifier(rawValue: 1 << 1)+    public static let `private` = Modifier(rawValue: 1 << 2)+    public static let privateSet = Modifier(rawValue: 1 << 3)

+// Created by Tyler Hedrick on 8/18/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class PropertyAnalyzerSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!+    var sut = PropertyAnalyzer(typeName: "FakeType")++    beforeEach {+      sut = PropertyAnalyzer(typeName: "FakeType")+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("when there are no properties") {+        beforeEach {+          let content = """+                        public final class FakeType {}+                        """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns type info with empty property list") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties).to(beEmpty())+        }+      }++      context("when there is a property") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("returns nil if the type name is not present") {+          let sut = PropertyAnalyzer(typeName: "AnotherType")+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beNil())+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeProperties.PropertyData(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              modifiers: [.public, .instance])+          ]+        }+      }++      context("when there is a property in a nested type with the same type name") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"++            enum FakeType {+              static let foo: String = "Hola"+            }+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        /*+         This is actually not the ideal result of this and is a limitation of the implementation+         Ideally you would have to pass in `FakeType.FakeType` to get this nested type's property+         information. For now we are accepting this limitation and have this test to showcase+         what happens in this scenario.+         */+        it("detects and merges the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          let propSet = Set(result?.properties ?? [])+          let expectedPropSet: Set<TypeProperties.PropertyData> = [+            .init(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              modifiers: [.public, .instance]),+            .init(+              name: "foo",+              typeAnnotation: "String",+              comment: "",+              modifiers: [.internal, .static])+          ]+          expect(propSet) == expectedPropSet+        }

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - PropertyAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds property information for the provided type in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeProperties? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeProperties?+    let visitor = TypeSyntaxVisitor(typeName: typeName) { [unowned self] typeProperties in+      guard self.typeName == typeProperties.name else { return }+      result = try? typeProperties.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(typeName: String, onNodeVisit: @escaping (_ info: TypeProperties) -> Void) {+    self.onNodeVisit = onNodeVisit+    self.typeName = typeName+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    if node.identifier.text == typeName {+      processNode(node, withName: node.identifier.text, members: node.members.members)+    }+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if+      let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self),+      typeIdentifier.name.text == typeName+    {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeProperties) -> Void+  private let typeName: String++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeProperties.PropertyData]()+    let propertyVisitor = PropertySyntaxVisitor(typeName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(typeName: String, onNodeVisit: @escaping (_ info: TypeProperties.PropertyData) -> Void) {+    self.typeName = typeName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    let modifier = findModifiers(from: node)++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+    }++    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            modifiers: modifier))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // e.g.:+        // public let thing: String = "Hello" has a type annotation, String which makes this easy+        // public let thing = "Hello" does not have a type annotation, and I don't know how to handle this case.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          modifiers: modifier))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let typeName: String+  private let onNodeVisit: (_ info: TypeProperties.PropertyData) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }++  private func findModifiers(from node: VariableDeclSyntax) -> TypeProperties.Modifier {+    let modifiersString: [String] = node.children+      .compactMap { $0.as(ModifierListSyntax.self) }+      .reduce(into: []) { result, syntax in+        let modifiers: [String] = syntax.children+          .compactMap { $0.as(DeclModifierSyntax.self) }+          .map { modifierSyntax in+            if+              let leftParen = modifierSyntax.detailLeftParen,+              let detail = modifierSyntax.detail,+              let rightParen = modifierSyntax.detailRightParen+            {+              return modifierSyntax.name.text + leftParen.text + detail.text + rightParen.text+            }+            return modifierSyntax.name.text+        }+        result.append(contentsOf: modifiers)+      }++    var modifier = modifiersString.reduce(TypeProperties.Modifier()) { result, stringValue in+      let modifier = TypeProperties.Modifier(stringValue: stringValue)+      return result.union(modifier)+    }++    // If there are no explicit modifiers, this is an internal property+    if !modifier.contains(.public) &&+      !modifier.contains(.fileprivate) &&+      !modifier.contains(.private)+    {+      modifier = modifier.union(.internal)+    }++    // If the variable isn't static, it's an instance variable+    if !modifier.contains(.static) {+      modifier = modifier.union(.instance)+    }++    return modifier+  }+}++// MARK: - TypeProperties++/// Information about a type as well as its associated properties+public struct TypeProperties: Hashable {++  public struct Modifier: Hashable, OptionSet {+    public let rawValue: Int++    public static let `internal` = Modifier(rawValue: 1 << 0)+    public static let `public` = Modifier(rawValue: 1 << 1)+    public static let `private` = Modifier(rawValue: 1 << 2)+    public static let privateSet = Modifier(rawValue: 1 << 3)+    public static let `fileprivate` = Modifier(rawValue: 1 << 4)+    public static let `instance` = Modifier(rawValue: 1 << 5)+    public static let `static` = Modifier(rawValue: 1 << 6)++    public init(rawValue: Int)  {+      self.rawValue = rawValue+    }++    public init(stringValue: String) {+      switch stringValue {+      case "public": self = .public+      case "private": self = .private+      case "private(set)": self = .privateSet+      case "fileprivate": self = .fileprivate+      case "internal": self = .internal+      case "static": self = .static+      default: self = []+      }+    }+  }++  public struct PropertyData: Hashable {+    /// The name of the property+    public let name: String+    /// The Type annotation of the property if it's present+    public let typeAnnotation: String?+    /// Any comments associated with the property+    public let comment: String+    /// Modifier set for this type+    public let modifiers: Modifier+  }++  /// The name of the type.+  public let name: String+  /// The properties on this type+  public let properties: [PropertyData]+}++extension TypeProperties {+  struct MergeError: Error, CustomStringConvertible {++    init(errorMessage: String) {+      self.errorMessage = errorMessage+    }++    var description: String { errorMessage }++    private let errorMessage: String+  }+}++extension TypeProperties.MergeError {+  static var invalidNames = TypeProperties.MergeError(+    errorMessage: "Invalid types - the type names must match to be merged.")+}++extension TypeProperties {+  func merge(with other: TypeProperties?) throws -> TypeProperties {+    guard let other = other else {+      return self+    }+    guard name == other.name else {+      throw MergeError.invalidNames+    }+    return TypeProperties(+      name: name,+      properties: Array(Set(properties).union(Set(other.properties))))+  }+}++extension TypeProperties.Modifier: CustomStringConvertible, CustomDebugStringConvertible {+  public var description: String {+    var outputValues: [String] = []+    // Order is important here! Access control modifiers should always go before scope modifiers+    // Access control modifiers+    if contains(.public) { outputValues.append("public") }+    if contains(.private) { outputValues.append("private") }+    if contains(.privateSet) { outputValues.append("private(set)") }

+// Created by Tyler Hedrick on 3/27/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class PropertyAnalyzerSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!+    var sut = PropertyAnalyzer(typeName: "FakeType")++    beforeEach {+      sut = PropertyAnalyzer(typeName: "FakeType")+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("TypeWithPropInfo.merge(other:)") {+      let type1 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance)+      ])+      let type2 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])+      let type3 = TypeWithPropInfo(+        name: "AnotherType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])++      context("when both types have the same name") {+        let result = try? type1.merge(with: type2)+        it("succeeds") {+          expect(result?.name) == "MyType"+        }++        it("has merged props") {+          let set = Set(result?.properties ?? [])+          let expectedSet: Set<TypeWithPropInfo.PropInfo> = [+            TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance),+            TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+          ]+          expect(set) == expectedSet+        }+      }++      context("when the types don't match") {+        it("fails to merge and asserts") {+          expect { try type1.merge(with: type3) }.to(throwError())+        }+      }++      context("when the other type is nil") {+        it("returns the original") {+          expect(try? type1.merge(with: nil)) == type1+        }+      }+    }++    describe("analyze(fileURL:)") {+      context("when there are no properties") {+        beforeEach {+          let content = """+                        public final class FakeType {}+                        """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns type info with empty property list") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties).to(beEmpty())+        }+      }++      context("when there is a property") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("returns nil if the type name is not present") {+          let sut = PropertyAnalyzer(typeName: "AnotherType")+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beNil())+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (struct)") {+        beforeEach {+          let content = """+          public struct FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (enum)") {+        beforeEach {+          let content = """+          public enum FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (protocol)") {+        beforeEach {+          let content = """+          public protocol FakeType {+            var thing: String { get }+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .internal,+              scope: .instance)+          ]+        }+      }++      context("when there is a property extension") {+        beforeEach {+          let content = """+          public class FakeType { }++          extension FakeType {+            var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .internal,+              scope: .instance)+          ]+        }+      }++      context("when there are multiple properites") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"+            var foo: Int = 4+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          let propSet = Set(result?.properties ?? [])+          let expectedPropSet: Set<TypeWithPropInfo.PropInfo> = [+            .init(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance),+            .init(name: "foo", typeAnnotation: "Int", comment: "", access: .internal, scope: .instance)+          ]+          expect(propSet) == expectedPropSet+        }+      }++      context("when there is a static property") {+        beforeEach {+          let content = """+          public final class FakeType {+            public static var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .static)+          ]+        }+      }++      context("when there is a private property") {+        beforeEach {+          let content = """+          public final class FakeType {+            private static var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .private,+              scope: .static)+          ]+        }+      }++      context("when there is a fileprivate property") {+        beforeEach {+          let content = """+          public final class FakeType {+            fileprivate static var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .fileprivate,+              scope: .static)+          ]+        }+      }++      context("when there is no type annotation") {+        beforeEach {+          let content = """+          public final class FakeType {+            private static var thing = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with no type information") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: nil,+              comment: "",+              access: .private,+              scope: .static)+          ]+        }+      }++      context("when there is a line comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            // The thing+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "// The thing",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a doc line comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            /// The thing+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "/// The thing",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a block comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            /* The thing */+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "/* The thing */",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a doc block comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            /** The thing */+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "/** The thing */",+              access: .public,+              scope: .instance)+          ]+        }+      }++    }+  }+}

+// Created by Tyler Hedrick on 3/27/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class PropertyAnalyzerSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!+    var sut = PropertyAnalyzer(typeName: "FakeType")++    beforeEach {+      sut = PropertyAnalyzer(typeName: "FakeType")+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("TypeWithPropInfo.merge(other:)") {+      let type1 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance)+      ])+      let type2 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])+      let type3 = TypeWithPropInfo(+        name: "AnotherType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])++      context("when both types have the same name") {+        let result = try? type1.merge(with: type2)+        it("succeeds") {+          expect(result?.name) == "MyType"+        }++        it("has merged props") {+          let set = Set(result?.properties ?? [])+          let expectedSet: Set<TypeWithPropInfo.PropInfo> = [+            TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance),+            TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+          ]+          expect(set) == expectedSet+        }+      }++      context("when the types don't match") {+        it("fails to merge and asserts") {+          expect { try type1.merge(with: type3) }.to(throwError())+        }+      }++      context("when the other type is nil") {+        it("returns the original") {+          expect(try? type1.merge(with: nil)) == type1+        }+      }+    }++    describe("analyze(fileURL:)") {+      context("when there are no properties") {+        beforeEach {+          let content = """+                        public final class FakeType {}+                        """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns type info with empty property list") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties).to(beEmpty())+        }+      }++      context("when there is a property") {+        beforeEach {+          let content = """+          public final class FakeType {

+// Created by Tyler Hedrick on 8/17/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import ArgumentParser+import Foundation+import SwiftInspectorCore++final class PropertyAnalyzerCommand: ParsableCommand {+  static var configuration = CommandConfiguration(+    commandName: "properties",+    abstract: "Finds property information for the provided type"+  )++  @Option(help: nameArgumentHelp)+  var name: String++  @Option(help: "The absolute path of the file to inspect")+  var path: String++  /// Runs the command+  func run() throws {+    let cachedSyntaxTree = CachedSyntaxTree()++    let analyzer = PropertyAnalyzer(typeName: name, cachedSyntaxTree: cachedSyntaxTree)+    let fileURL = URL(fileURLWithPath: path)+    if let propertyInformation = try analyzer.analyze(fileURL: fileURL) {+      print(outputString(from: propertyInformation))+    }+  }++  /// Validates if the arguments of this command are valid+  func validate() throws {+    guard !name.isEmpty else {+      throw InspectorError.emptyArgument(argumentName: "--name")+    }+    guard !path.isEmpty else {+      throw InspectorError.emptyArgument(argumentName: "--path")+    }+    let pathURL = URL(fileURLWithPath: path)+    guard FileManager.default.isSwiftFile(at: pathURL) else {+      throw InspectorError.invalidArgument(argumentName: "--path", value: path)+    }+  }++  private func outputString(from statement: TypeWithPropInfo) -> String {+    let propString = statement.properties.map { propInfo in+      "(\(propInfo.name)|\(propInfo.access)|\(propInfo.scope))"

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element

+// Created by Tyler Hedrick on 3/27/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class PropertyAnalyzerSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!+    var sut = PropertyAnalyzer(typeName: "FakeType")++    beforeEach {+      sut = PropertyAnalyzer(typeName: "FakeType")+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("TypeWithPropInfo.merge(other:)") {+      let type1 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance)+      ])+      let type2 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])+      let type3 = TypeWithPropInfo(+        name: "AnotherType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])++      context("when both types have the same name") {+        let result = try? type1.merge(with: type2)+        it("succeeds") {+          expect(result?.name) == "MyType"+        }++        it("has merged props") {+          let set = Set(result?.properties ?? [])+          let expectedSet: Set<TypeWithPropInfo.PropInfo> = [+            TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance),+            TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+          ]+          expect(set) == expectedSet+        }+      }++      context("when the types don't match") {+        it("fails to merge and asserts") {+          expect { try type1.merge(with: type3) }.to(throwError())+        }+      }++      context("when the other type is nil") {+        it("returns the original") {+          expect(try? type1.merge(with: nil)) == type1+        }+      }+    }++    describe("analyze(fileURL:)") {+      context("when there are no properties") {+        beforeEach {+          let content = """+                        public final class FakeType {}+                        """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns type info with empty property list") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties).to(beEmpty())+        }+      }++      context("when there is a property") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("returns nil if the type name is not present") {+          let sut = PropertyAnalyzer(typeName: "AnotherType")+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beNil())+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (struct)") {+        beforeEach {+          let content = """+          public struct FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (enum)") {+        beforeEach {+          let content = """+          public enum FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (protocol)") {+        beforeEach {+          let content = """+          public protocol FakeType {+            var thing: String { get }+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .internal,+              scope: .instance)+          ]+        }+      }++      context("when there is a property extension") {+        beforeEach {+          let content = """+          public class FakeType { }++          extension FakeType {+            var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .internal,+              scope: .instance)+          ]+        }+      }++      context("when there are multiple properites") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"+            var foo: Int = 4+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          let propSet = Set(result?.properties ?? [])+          let expectedPropSet: Set<TypeWithPropInfo.PropInfo> = [+            .init(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance),+            .init(name: "foo", typeAnnotation: "Int", comment: "", access: .internal, scope: .instance)+          ]+          expect(propSet) == expectedPropSet+        }+      }++      context("when there is a static property") {+        beforeEach {+          let content = """+          public final class FakeType {+            public static var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .static)+          ]+        }+      }++      context("when there is a private property") {

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          access: access,+          scope: scope))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let parentName: String

+// Created by Tyler Hedrick on 3/27/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class PropertyAnalyzerSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!+    var sut = PropertyAnalyzer(typeName: "FakeType")++    beforeEach {+      sut = PropertyAnalyzer(typeName: "FakeType")+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("TypeWithPropInfo.merge(other:)") {+      let type1 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance)+      ])+      let type2 = TypeWithPropInfo(+        name: "MyType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])+      let type3 = TypeWithPropInfo(+        name: "AnotherType",+        properties: [+          TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+      ])++      context("when both types have the same name") {+        let result = try? type1.merge(with: type2)+        it("succeeds") {+          expect(result?.name) == "MyType"+        }++        it("has merged props") {+          let set = Set(result?.properties ?? [])+          let expectedSet: Set<TypeWithPropInfo.PropInfo> = [+            TypeWithPropInfo.PropInfo(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance),+            TypeWithPropInfo.PropInfo(name: "foo", typeAnnotation: "Int", comment: "", access: .public, scope: .instance)+          ]+          expect(set) == expectedSet+        }+      }++      context("when the types don't match") {+        it("fails to merge and asserts") {+          expect { try type1.merge(with: type3) }.to(throwError())+        }+      }++      context("when the other type is nil") {+        it("returns the original") {+          expect(try? type1.merge(with: nil)) == type1+        }+      }+    }++    describe("analyze(fileURL:)") {+      context("when there are no properties") {+        beforeEach {+          let content = """+                        public final class FakeType {}+                        """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns type info with empty property list") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties).to(beEmpty())+        }+      }++      context("when there is a property") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("returns nil if the type name is not present") {+          let sut = PropertyAnalyzer(typeName: "AnotherType")+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beNil())+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (struct)") {+        beforeEach {+          let content = """+          public struct FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (enum)") {+        beforeEach {+          let content = """+          public enum FakeType {+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a property (protocol)") {+        beforeEach {+          let content = """+          public protocol FakeType {+            var thing: String { get }+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .internal,+              scope: .instance)+          ]+        }+      }++      context("when there is a property extension") {+        beforeEach {+          let content = """+          public class FakeType { }++          extension FakeType {+            var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the type name") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.name) == "FakeType"+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .internal,+              scope: .instance)+          ]+        }+      }++      context("when there are multiple properites") {+        beforeEach {+          let content = """+          public final class FakeType {+            public var thing: String = "Hello, World"+            var foo: Int = 4+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the properties") {+          let result = try? sut.analyze(fileURL: fileURL)+          let propSet = Set(result?.properties ?? [])+          let expectedPropSet: Set<TypeWithPropInfo.PropInfo> = [+            .init(name: "thing", typeAnnotation: "String", comment: "", access: .public, scope: .instance),+            .init(name: "foo", typeAnnotation: "Int", comment: "", access: .internal, scope: .instance)+          ]+          expect(propSet) == expectedPropSet+        }+      }++      context("when there is a static property") {+        beforeEach {+          let content = """+          public final class FakeType {+            public static var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .public,+              scope: .static)+          ]+        }+      }++      context("when there is a private property") {+        beforeEach {+          let content = """+          public final class FakeType {+            private static var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .private,+              scope: .static)+          ]+        }+      }++      context("when there is a fileprivate property") {+        beforeEach {+          let content = """+          public final class FakeType {+            fileprivate static var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "",+              access: .fileprivate,+              scope: .static)+          ]+        }+      }++      context("when there is no type annotation") {+        beforeEach {+          let content = """+          public final class FakeType {+            private static var thing = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with no type information") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: nil,+              comment: "",+              access: .private,+              scope: .static)+          ]+        }+      }++      context("when there is a line comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            // The thing+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "// The thing",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a doc line comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            /// The thing+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "/// The thing",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a block comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            /* The thing */+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "/* The thing */",+              access: .public,+              scope: .instance)+          ]+        }+      }++      context("when there is a doc block comment") {+        beforeEach {+          let content = """+          public final class FakeType {+            /** The thing */+            public var thing: String = "Hello, World"+          }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("detects the property with the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result?.properties) == [+            TypeWithPropInfo.PropInfo(+              name: "thing",+              typeAnnotation: "String",+              comment: "/** The thing */",+              access: .public,+              scope: .instance)+          ]+        }+      }

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {

+// Created by Tyler Hedrick on 8/17/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import ArgumentParser+import Foundation+import SwiftInspectorCore++final class PropertyAnalyzerCommand: ParsableCommand {+  static var configuration = CommandConfiguration(+    commandName: "properties",+    abstract: "Finds property information for the provided type"+  )++  @Option(help: nameArgumentHelp)+  var name: String++  @Option(help: "The absolute path of the file to inspect")+  var path: String++  /// Runs the command+  func run() throws {+    let cachedSyntaxTree = CachedSyntaxTree()++    let analyzer = PropertyAnalyzer(typeName: name, cachedSyntaxTree: cachedSyntaxTree)+    let fileURL = URL(fileURLWithPath: path)+    if let propertyInformation = try analyzer.analyze(fileURL: fileURL) {+      print(outputString(from: propertyInformation))+    }+  }++  /// Validates if the arguments of this command are valid+  func validate() throws {+    guard !name.isEmpty else {+      throw InspectorError.emptyArgument(argumentName: "--name")+    }+    guard !path.isEmpty else {+      throw InspectorError.emptyArgument(argumentName: "--path")+    }+    let pathURL = URL(fileURLWithPath: path)+    guard FileManager.default.isSwiftFile(at: pathURL) else {+      throw InspectorError.invalidArgument(argumentName: "--path", value: path)+    }+  }++  private func outputString(from statement: TypeWithPropInfo) -> String {+    let propString = statement.properties.map { propInfo in+      "(\(propInfo.name)|\(propInfo.access)|\(propInfo.scope))"

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          access: access,+          scope: scope))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let parentName: String+  private let onNodeVisit: (_ info: TypeWithPropInfo.PropInfo) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }+}++// MARK: - TypeWithPropInfo++/// Information about a located type. Indices start with 0.

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          access: access,+          scope: scope))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let parentName: String+  private let onNodeVisit: (_ info: TypeWithPropInfo.PropInfo) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }+}++// MARK: - TypeWithPropInfo++/// Information about a located type. Indices start with 0.+public struct TypeWithPropInfo: Hashable {++  public enum Access: String {+    case `public`+    case `internal`+    case `private`+    case `fileprivate`+  }++  public enum Scope: String {+    case instance+    case `static`+  }++  public struct PropInfo: Hashable {

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          access: access,+          scope: scope))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let parentName: String+  private let onNodeVisit: (_ info: TypeWithPropInfo.PropInfo) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }+}++// MARK: - TypeWithPropInfo++/// Information about a located type. Indices start with 0.+public struct TypeWithPropInfo: Hashable {++  public enum Access: String {+    case `public`+    case `internal`+    case `private`+    case `fileprivate`+  }++  public enum Scope: String {+    case instance+    case `static`+  }++  public struct PropInfo: Hashable {+    /// The name of the property+    public let name: String+    /// The Type annotation of the property if it's present+    public let typeAnnotation: String?+    /// Any comments associated with the property+    public let comment: String+    /// Access control of this property+    public let access: Access+    /// Scope of this property+    public let scope: Scope+  }++  /// The name of the type.+  public let name: String+  /// The properites on this type

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          access: access,+          scope: scope))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let parentName: String+  private let onNodeVisit: (_ info: TypeWithPropInfo.PropInfo) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }+}++// MARK: - TypeWithPropInfo++/// Information about a located type. Indices start with 0.+public struct TypeWithPropInfo: Hashable {++  public enum Access: String {

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file

+// Created by Tyler Hedrick on 8/14/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import SwiftSyntax++// MARK: - TypeLocationAnalyzer++public final class PropertyAnalyzer: Analyzer {++  /// - Parameter typeName: The name of the type to get property information for+  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(typeName: String, cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.typeName = typeName+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Finds the location(s) of the specified type name in the Swift file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> TypeWithPropInfo? {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result: TypeWithPropInfo?+    let visitor = TypeSyntaxVisitor() { [unowned self] typeWithPropInfo in+      guard self.typeName == typeWithPropInfo.name else { return }+      result = try? typeWithPropInfo.merge(with: result)+    }+    visitor.walk(syntax)+    return result+  }++  // MARK: Private++  private let cachedSyntaxTree: CachedSyntaxTree+  private let typeName: String+}++// MARK: - TypeLocationSyntaxVisitor++private final class TypeSyntaxVisitor: SyntaxVisitor {++  init(onNodeVisit: @escaping (_ info: TypeWithPropInfo) -> Void) {+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {+    processNode(node, withName: node.identifier.text, members: node.members.members)+    return .visitChildren+  }++  override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {+    if let typeIdentifier = node.extendedType.as(SimpleTypeIdentifierSyntax.self) {+      processNode(node, withName: typeIdentifier.name.text, members: node.members.members)+    }+    return .visitChildren+  }++  // MARK: Private++  private let onNodeVisit: (_ info: TypeWithPropInfo) -> Void++  private func processNode<Node>(_ node: Node, withName name: String, members: MemberDeclListSyntax) where Node: SyntaxProtocol {+    var result = [TypeWithPropInfo.PropInfo]()+    let propertyVisitor = PropertySyntaxVisitor(parentName: name) { info in+      result.append(info)+    }+    propertyVisitor.walk(node)+    onNodeVisit(.init(name: name, properties: result))+  }+}++// MARK: - PropertySyntaxVisitor++private final class PropertySyntaxVisitor: SyntaxVisitor {++  init(parentName: String, onNodeVisit: @escaping (_ info: TypeWithPropInfo.PropInfo) -> Void) {+    self.parentName = parentName+    self.onNodeVisit = onNodeVisit+  }++  override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind {+    var leadingTrivia: Trivia? = node.leadingTrivia+    var access: TypeWithPropInfo.Access = .internal+    var scope: TypeWithPropInfo.Scope = .instance++    node.modifiers?.forEach { modifier in+      // leading trivia is on the first modifier, or the node itself if no modifiers are present+      leadingTrivia = leadingTrivia ?? modifier.leadingTrivia+      // This attempts to get any access information from the node's modifiers+      if let modifierAccess = TypeWithPropInfo.Access(rawValue: modifier.name.text) {+        access = modifierAccess+      }+      // this attempts to get any scope information from the node's modifiers+      if let modifierScope = TypeWithPropInfo.Scope(rawValue: modifier.name.text) {+        scope = modifierScope+      }+    }++    // in practice this `bindings` array only has 1 element+    node.bindings.forEach { binding in+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {+        if+          let typeAnnotation = binding.typeAnnotation,+          let simpleTypeIdentifier = typeAnnotation.type.as(SimpleTypeIdentifierSyntax.self)+        {+          onNodeVisit(.init(+            name: identifier.identifier.text,+            typeAnnotation: simpleTypeIdentifier.name.text,+            comment: comment(from: leadingTrivia),+            access: access,+            scope: scope))+          return+        }+        // no type annotation was found. In this case it's much more complicated to get+        // the type information for a variable.+        // TODO: Include logic to get types of any variable declaration+        onNodeVisit(.init(+          name: identifier.identifier.text,+          typeAnnotation: nil,+          comment: comment(from: leadingTrivia),+          access: access,+          scope: scope))+      }+    }++    return .skipChildren+  }++  // MARK: Private++  private let parentName: String+  private let onNodeVisit: (_ info: TypeWithPropInfo.PropInfo) -> Void++  private func comment(from trivia: Trivia?) -> String {+    guard let trivia = trivia else { return "" }+    return trivia.compactMap { piece -> String? in+      switch piece {+      case .lineComment(let str): return str+      case .blockComment(let str): return str+      case .docLineComment(let str): return str+      case .docBlockComment(let str): return str+      default: return nil+      }+    }.joined(separator: "\n")+  }+}++// MARK: - TypeWithPropInfo++/// Information about a located type. Indices start with 0.+public struct TypeWithPropInfo: Hashable {

+// Created by Tyler Hedrick on 8/17/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class PropertyAnalyzerCommandSpec: QuickSpec {+  override func spec() {+    describe("run") {++      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["properties"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTask.run(withArguments: ["properties", "--path", ""])+          expect(result?.didFail) == true+        }++        it("fails when not provided") {+          let result = try? TestTask.run(withArguments: ["properties", "--path"])+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTask.run(withArguments: ["properties", "--path", "/fake/path"])+          expect(result?.didFail) == true+        }++        it("fails when name is present but the file is invalid") {+          let result = try? TestTask.run(withArguments: ["properties", "--path", "/fake/path", "--name", "SomeType"])+          expect(result?.didFail) == true+        }+      }++      context("when name is passed") {+        var fileURL: URL!++        beforeEach {+          fileURL = try? Temporary.makeFile(content: """+          final class Some {+            public var thing: String = "Hello, World"+          }+          """)+        }++        afterEach {+          try? Temporary.removeItem(at: fileURL)+        }++        it("fails when name is empty") {+          let result = try? TestTask.run(withArguments: ["properties", "--path", fileURL.path, "--name", ""])+          expect(result?.didFail) == true+        }++        it("fails when name is not provided") {+          let result = try? TestTask.run(withArguments: ["properties", "--path", fileURL.path, "--name"])+          expect(result?.didFail) == true+        }++        it("fails when path is empty") {+          let result = try? TestTask.run(withArguments: ["properties", "--name", "Some"])+          expect(result?.didFail) == true+        }++        it("succeeds") {+          let result = try? TestTask.run(withArguments: ["properties", "--path", fileURL.path, "--name", "Some"])+          expect(result?.didSucceed) == true+        }++        it("returns the type name with property information including the name, access, and scope") {+          let result = try? TestTask.run(withArguments: ["properties", "--path", fileURL.path, "--name", "Some"])+          expect(result?.outputMessage).to(contain("Some:(thing|public|instance)"))

+// Created by Tyler Hedrick on 8/13/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class TypesCommandSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }+++    describe("run") {+      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["types"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTypesCommandTask.run(path: "")+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTypesCommandTask.run(path: "/fake/path")+          expect(result?.didFail) == true+        }+      }++      context("when path is valid") {+        it("succeeds") {+          fileURL = try? Temporary.makeFile(content: "struct Foo { }")+          let path = fileURL?.path ?? ""+          let result = try? TestTypesCommandTask.run(path: path)+          expect(result?.didSucceed) == true+        }++        it("runs and outputs the result without comment") {+          fileURL = try? Temporary.makeFile(content: """+                                                   // This is a comment+                                                   struct Foo { }+                                                   """)+          let path = fileURL?.path ?? ""+          let result = try? TestTypesCommandTask.run(path: path)+          expect(result?.outputMessage).to(contain("Foo,struct"))

+// Created by Tyler Hedrick on 8/12/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.+++import Foundation+import SwiftSyntax++public final class TypesAnalyzer: Analyzer {++  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Analyzes the types located in the provided file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> [TypeInfo] {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result = [TypeInfo]()+    let visitor = TypeInfoSyntaxVisitor() { typeInfo in

+// Created by Tyler Hedrick on 8/13/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class TypesCommandSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }+++    describe("run") {+      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["types"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTypesCommandTask.run(path: "")+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTypesCommandTask.run(path: "/fake/path")+          expect(result?.didFail) == true+        }+      }++      context("when path is valid") {

+// Created by Tyler Hedrick on 8/13/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class TypesCommandSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }+++    describe("run") {+      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["types"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTypesCommandTask.run(path: "")+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTypesCommandTask.run(path: "/fake/path")+          expect(result?.didFail) == true+        }+      }++      context("when path is valid") {+        it("succeeds") {+          fileURL = try? Temporary.makeFile(content: "struct Foo { }")+          let path = fileURL?.path ?? ""+          let result = try? TestTypesCommandTask.run(path: path)+          expect(result?.didSucceed) == true+        }++        it("runs and outputs the result without comment") {+          fileURL = try? Temporary.makeFile(content: """+                                                   // This is a comment+                                                   struct Foo { }+                                                   """)+          let path = fileURL?.path ?? ""+          let result = try? TestTypesCommandTask.run(path: path)+          expect(result?.outputMessage).to(contain("Foo,struct"))

 final class TypesCommand: ParsableCommand {     return "\(info.name),\(info.type),\(comment)"   } }++private var commentFlagHelp = ArgumentHelp(+  "The granularity of the output",

 final class TypesCommandSpec: QuickSpec {                                                    struct Foo { }                                                    """)           let path = fileURL?.path ?? ""-          let result = try? TestTask.run(withArguments: ["types", "--path", path])-          expect(result!.outputMessage).to(contain("Foo,struct,// This is a comment"))+          let result = try? TestTypesCommandTask.run(path: path, arguments: ["--enable-include-comments"])+          expect(result?.outputMessage).to(contain("Foo,struct,// This is a comment"))+        }+      }++      context("when path is a folder") {+        var folderURL: URL!+        beforeEach {+          folderURL = try! Temporary.makeFolder()+        }+        afterEach {+          try! Temporary.removeItem(at: folderURL)+        }++        it("succeeds") {+          let result = try? TestTypesCommandTask.run(path: folderURL.path)++          expect(result?.didSucceed) == true+        }++        it("outputs the correct types") {+          let _ = try? Temporary.makeFile(+            content: """+                     class Foo { }+                     """,+            atPath: folderURL.path)++          let _ = try? Temporary.makeFile(+          content: """+                   class Bar { }+                   """,+          atPath: folderURL.path)++          let result = try? TestTypesCommandTask.run(path: folderURL.path)+          let outputMessageLines = result?.outputMessage?.split { $0.isNewline }+          expect(outputMessageLines).to(contain(["Foo,class", "Bar,class"]))         }       }      }   } }++private struct TestTypesCommandTask {

+// Created by Tyler Hedrick on 8/13/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class TypesCommandSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }+++    describe("run") {+      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["types"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTask.run(withArguments: ["types", "--path", ""])+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTask.run(withArguments: ["types", "--path", "/fake/path"])+          expect(result?.didFail) == true+        }+      }++      context("when path is valid") {+        it("runs and outputs the result (without comment)") {+          fileURL = try? Temporary.makeFile(content: "struct Foo { }")+          let path = fileURL?.path ?? ""+          let result = try? TestTask.run(withArguments: ["types", "--path", path])+          expect(result!.outputMessage).to(contain("Foo,struct"))+        }++        it("runs and outputs the result (with comment)") {+          fileURL = try? Temporary.makeFile(content: """+                                                   // This is a comment+                                                   struct Foo { }+                                                   """)+          let path = fileURL?.path ?? ""+          let result = try? TestTask.run(withArguments: ["types", "--path", path])+          expect(result!.outputMessage).to(contain("Foo,struct,// This is a comment"))

+// Created by Tyler Hedrick on 8/12/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.+++import Foundation+import SwiftSyntax++public final class TypesAnalyzer: Analyzer {++  /// - Parameter cachedSyntaxTree: The cached syntax tree to return the AST tree from+  public init(cachedSyntaxTree: CachedSyntaxTree = .init()) {+    self.cachedSyntaxTree = cachedSyntaxTree+  }++  /// Analyzes the types located in the provided file+  /// - Parameter fileURL: The fileURL where the Swift file is located+  public func analyze(fileURL: URL) throws -> [TypeInfo] {+    let syntax: SourceFileSyntax = try cachedSyntaxTree.syntaxTree(for: fileURL)+    var result = [TypeInfo]()+    let visitor = TypeInfoSyntaxVisitor() { typeInfo in

+// Created by Tyler Hedrick 8/13/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import Nimble+import Quick++@testable import SwiftInspectorCore++final class TypesAnalyzerSpec: QuickSpec {++  override func spec() {+    var fileURL: URL!+    var sut: TypesAnalyzer!++    beforeEach {+      sut = TypesAnalyzer()+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("there are no types present") {+        beforeEach {+          let content =+          """+          import Foundation+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns empty array") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beEmpty())+        }+      }++      context("struct is present") {+        beforeEach {+          let content =+          """+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct+        }+      }++      context("enum is present") {+        beforeEach {+          let content =+          """+          enum Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the enum") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .enum+        }+      }++      context("class is present") {+        beforeEach {+          let content =+          """+          class Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the class") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .class+        }+      }++      context("protocol is present") {+        beforeEach {+          let content =+          """+          protocol Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the protocol") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .protocol+        }+      }++      context("struct is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct including the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct+          expect(result!.first!.comment) == "// This is a comment"+        }+      }++      context("enum is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment+          enum Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the enum including the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .enum+          expect(result!.first!.comment) == "// This is a comment"+        }+      }++      context("class is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment+          class Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the class including the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .class+          expect(result!.first!.comment) == "// This is a comment"+        }+      }++      context("protocol is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment+          protocol Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the protocol including the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .protocol+          expect(result!.first!.comment) == "// This is a comment"+        }+      }++      context("multiple types present") {+        beforeEach {+          let content =+          """+          // This is a comment+          protocol Foo { }++          // This is a different comment+          private final class Bar: Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for both types including the comments") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .protocol+          expect(result!.first!.comment) == "// This is a comment"++          expect(result![1].name) == "Bar"+          expect(result![1].type) == .class+          expect(result![1].comment) == "// This is a different comment"+        }+      }

+// Created by Tyler Hedrick 8/13/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import Nimble+import Quick++@testable import SwiftInspectorCore++final class TypesAnalyzerSpec: QuickSpec {++  override func spec() {+    var fileURL: URL!+    var sut: TypesAnalyzer!++    beforeEach {+      sut = TypesAnalyzer()+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("there are no types present") {+        beforeEach {+          let content =+          """+          import Foundation+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns empty array") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beEmpty())+        }+      }++      context("struct is present") {+        beforeEach {+          let content =+          """+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct+        }+      }++      context("enum is present") {+        beforeEach {+          let content =+          """+          enum Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the enum") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .enum+        }+      }++      context("class is present") {+        beforeEach {+          let content =+          """+          class Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the class") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .class+        }

+// Created by Tyler Hedrick 8/13/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import Nimble+import Quick++@testable import SwiftInspectorCore++final class TypesAnalyzerSpec: QuickSpec {++  override func spec() {+    var fileURL: URL!+    var sut: TypesAnalyzer!++    beforeEach {+      sut = TypesAnalyzer()+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("there are no types present") {+        beforeEach {+          let content =+          """+          import Foundation+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns empty array") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beEmpty())+        }+      }++      context("struct is present") {+        beforeEach {+          let content =+          """+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct+        }+      }++      context("enum is present") {+        beforeEach {+          let content =+          """+          enum Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the enum") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .enum+        }+      }++      context("class is present") {+        beforeEach {+          let content =+          """+          class Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the class") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .class+        }+      }++      context("protocol is present") {+        beforeEach {+          let content =+          """+          protocol Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the protocol") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .protocol+        }+      }++      context("struct is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct including the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct+          expect(result!.first!.comment) == "// This is a comment"+        }+      }++      context("enum is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment+          enum Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the enum including the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .enum+          expect(result!.first!.comment) == "// This is a comment"+        }+      }++      context("class is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment+          class Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the class including the comment") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .class+          expect(result!.first!.comment) == "// This is a comment"+        }+      }++      context("protocol is present with comment") {+        beforeEach {+          let content =+          """+          // This is a comment

+// Created by Tyler Hedrick 8/13/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import Nimble+import Quick++@testable import SwiftInspectorCore++final class TypesAnalyzerSpec: QuickSpec {++  override func spec() {+    var fileURL: URL!+    var sut: TypesAnalyzer!++    beforeEach {+      sut = TypesAnalyzer()+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("there are no types present") {+        beforeEach {+          let content =+          """+          import Foundation+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns empty array") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beEmpty())+        }+      }++      context("struct is present") {+        beforeEach {+          let content =+          """+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct

+// Created by Tyler Hedrick 8/13/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import Nimble+import Quick++@testable import SwiftInspectorCore++final class TypesAnalyzerSpec: QuickSpec {++  override func spec() {+    var fileURL: URL!+    var sut: TypesAnalyzer!++    beforeEach {+      sut = TypesAnalyzer()+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("there are no types present") {+        beforeEach {+          let content =+          """+          import Foundation+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns empty array") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beEmpty())+        }+      }++      context("struct is present") {+        beforeEach {+          let content =+          """+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct+        }+      }++      context("enum is present") {+        beforeEach {+          let content =+          """+          enum Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the enum") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .enum

+// Created by Tyler Hedrick on 8/13/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class TypesCommandSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }+++    describe("run") {+      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["types"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTask.run(withArguments: ["types", "--path", ""])+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTask.run(withArguments: ["types", "--path", "/fake/path"])+          expect(result?.didFail) == true+        }+      }++      context("when path is valid") {+        it("runs and outputs the result (without comment)") {+          fileURL = try? Temporary.makeFile(content: "struct Foo { }")+          let path = fileURL?.path ?? ""+          let result = try? TestTask.run(withArguments: ["types", "--path", path])+          expect(result!.outputMessage).to(contain("Foo,struct"))

+// Created by Tyler Hedrick 8/13/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import Nimble+import Quick++@testable import SwiftInspectorCore++final class TypesAnalyzerSpec: QuickSpec {++  override func spec() {+    var fileURL: URL!+    var sut: TypesAnalyzer!++    beforeEach {+      sut = TypesAnalyzer()+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("there are no types present") {+        beforeEach {+          let content =+          """+          import Foundation+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns empty array") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beEmpty())+        }+      }++      context("struct is present") {+        beforeEach {+          let content =+          """+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"+          expect(result!.first!.type) == .struct+        }+      }++      context("enum is present") {+        beforeEach {+          let content =+          """+          enum Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the enum") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"

+// Created by Tyler Hedrick on 8/12/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import ArgumentParser+import Foundation+import SwiftInspectorCore++final class TypesCommand: ParsableCommand {+  static var configuration = CommandConfiguration(+    commandName: "types",+    abstract: "Finds information about types in a file"+  )++  @Option(help: "The absolute path to the file to inspect")+  var path: String++  /// Runs the command+  func run() throws {+    let cachedSyntaxTree = CachedSyntaxTree()+    let analyzer = TypesAnalyzer(cachedSyntaxTree: cachedSyntaxTree)+    let fileURL = URL(fileURLWithPath: path)+    let outputArray = try FileManager.default.swiftFiles(at: fileURL)

+// Created by Tyler Hedrick 8/13/20.+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Foundation+import Nimble+import Quick++@testable import SwiftInspectorCore++final class TypesAnalyzerSpec: QuickSpec {++  override func spec() {+    var fileURL: URL!+    var sut: TypesAnalyzer!++    beforeEach {+      sut = TypesAnalyzer()+    }++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }++    describe("analyze(fileURL:)") {+      context("there are no types present") {+        beforeEach {+          let content =+          """+          import Foundation+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns empty array") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).to(beEmpty())+        }+      }++      context("struct is present") {+        beforeEach {+          let content =+          """+          struct Foo { }+          """+          fileURL = try? Temporary.makeFile(content: content)+        }++        it("returns the type information for the struct") {+          let result = try? sut.analyze(fileURL: fileURL)+          expect(result).notTo(beEmpty())+          expect(result!.first!.name) == "Foo"

+// Created by Tyler Hedrick on 8/13/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class TypesCommandSpec: QuickSpec {+  override func spec() {+    var fileURL: URL!++    afterEach {+      guard let fileURL = fileURL else {+        return+      }+      try? Temporary.removeItem(at: fileURL)+    }+++    describe("run") {+      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["types"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTask.run(withArguments: ["types", "--path", ""])+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTask.run(withArguments: ["types", "--path", "/fake/path"])+          expect(result?.didFail) == true+        }+      }++      context("when path is valid") {+        it("runs and outputs the result (without comment)") {+          fileURL = try? Temporary.makeFile(content: "struct Foo { }")+          let path = fileURL?.path ?? ""+          let result = try? TestTask.run(withArguments: ["types", "--path", path])+          expect(result!.outputMessage).to(contain("Foo,struct"))+        }++        it("runs and outputs the result (with comment)") {+          fileURL = try? Temporary.makeFile(content: """+                                                   // This is a comment+                                                   struct Foo { }+                                                   """)+          let path = fileURL?.path ?? ""+          let result = try? TestTask.run(withArguments: ["types", "--path", path])+          expect(result!.outputMessage).to(contain("Foo,struct,// This is a comment"))

+// Created by Tyler Hedrick on 8/13/20.+//+// Copyright (c) 2020 Tyler Hedrick+//+// Distributed under the MIT License+//+// Permission is hereby granted, free of charge, to any person obtaining a copy+// of this software and associated documentation files (the "Software"), to deal+// in the Software without restriction, including without limitation the rights+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+// copies of the Software, and to permit persons to whom the Software is+// furnished to do so, subject to the following conditions:+//+// The above copyright notice and this permission notice shall be included in all+// copies or substantial portions of the Software.+//+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+// SOFTWARE.++import Nimble+import Quick+import Foundation++@testable import SwiftInspectorCore++final class TypesCommandSpec: QuickSpec {+  override func spec() {+    describe("run") {++      context("with no arguments") {+        it("fails") {+          let result = try? TestTask.run(withArguments: ["types"])+          expect(result?.didFail) == true+        }+      }++      context("when path is invalid") {+        it("fails when empty") {+          let result = try? TestTask.run(withArguments: ["types", "--path", ""])+          expect(result?.didFail) == true+        }++        it("fails when it doesn't exist") {+          let result = try? TestTask.run(withArguments: ["types", "--path", "/fake/path"])+          expect(result?.didFail) == true+        }