How to use parseDeclaredTypes method of conformance. class

...117    self.isInGenericContainingType = baseRawType.genericTypeContext.contains(where: { !$0.isEmpty })118    119    // Parse top-level declared methods and variables.120    var (methods, variables) = MockableType121      .parseDeclaredTypes(rawTypes: rawTypes,122                          baseRawType: baseRawType,123                          moduleNames: moduleNames,124                          rawTypeRepository: rawTypeRepository,125                          typealiasRepository: typealiasRepository)126    127    // Parse top-level declared generics.128    var genericTypes = substructure129      .compactMap({ structure -> GenericType? in130        guard let genericType = GenericType(from: structure,131                                            rawType: baseRawType,132                                            moduleNames: moduleNames,133                                            rawTypeRepository: rawTypeRepository) else { return nil }134        return genericType135      })136    var whereClauses = genericTypes.flatMap({ $0.whereClauses })137    let selfConstraintClauses: [WhereClause]138    let source = baseRawType.parsedFile.data139    if let nameSuffix = SourceSubstring.nameSuffixUpToBody.extract(from: baseRawType.dictionary,140                                                                   contents: source),141      let whereRange = nameSuffix.range(of: #"\bwhere\b"#, options: .regularExpression) {142      let topLevelClauses = nameSuffix[whereRange.upperBound..<nameSuffix.endIndex]143        .components(separatedBy: ",", excluding: .allGroups)144        .compactMap({ WhereClause(from: String($0)) })145        .map({ GenericType.qualifyWhereClause($0,146                                              containingType: baseRawType,147                                              moduleNames: moduleNames,148                                              rawTypeRepository: rawTypeRepository) })149      // Note: Superclass `Self` conformance must be done through the inheritance syntax, which is150      // passed via `selfConformanceTypes`.151      whereClauses.append(contentsOf: topLevelClauses.filter({ !$0.hasSelfConstraint }))152      selfConstraintClauses = topLevelClauses.filter({ $0.hasSelfConstraint })153    } else {154      selfConstraintClauses = []155    }156    157    // Parse inherited members and generics.158    let rawInheritedTypeNames = rawTypes159      .compactMap({ $0.dictionary[SwiftDocKey.inheritedtypes.rawValue] as? [StructureDictionary] })160      .flatMap({ $0 })161      .compactMap({ $0[SwiftDocKey.name.rawValue] as? String })162    let (inheritedTypes, _, allInheritedTypeNames, subclassesExternalType) =163      MockableType164        .parseInheritedTypes(rawInheritedTypeNames: rawInheritedTypeNames,165                             forConformance: false,166                             methods: &methods,167                             variables: &variables,168                             genericTypes: &genericTypes,169                             whereClauses: &whereClauses,170                             selfConstraintClauses: selfConstraintClauses,171                             mockableTypes: mockableTypes,172                             moduleNames: moduleNames,173                             genericTypeContext: genericTypeContext,174                             specializationContexts: specializationContexts,175                             baseRawType: baseRawType,176                             rawTypeRepository: rawTypeRepository,177                             typealiasRepository: typealiasRepository)178    self.inheritedTypes = inheritedTypes179    self.allInheritedTypeNames = allInheritedTypeNames180    self.opaqueInheritedTypeNames = opaqueInheritedTypeNames181      .union(Set(inheritedTypes.flatMap({ $0.opaqueInheritedTypeNames })))182    // Parse protocol `Self` conformance.183    let rawConformanceTypeNames = baseRawType.kind == .protocol ?184      baseRawType.selfConformanceTypeNames.union(185        Set(inheritedTypes.map({ $0.fullyQualifiedModuleName }))186      ) : []187    let (_, allSelfConformanceTypes, allSelfConformanceTypeNames, conformsToExternalType) =188      MockableType189        .parseInheritedTypes(rawInheritedTypeNames: Array(rawConformanceTypeNames),190                             forConformance: true,191                             methods: &methods,192                             variables: &variables,193                             genericTypes: &genericTypes,194                             whereClauses: &whereClauses,195                             selfConstraintClauses: selfConstraintClauses,196                             mockableTypes: mockableTypes,197                             moduleNames: moduleNames,198                             genericTypeContext: genericTypeContext,199                             specializationContexts: specializationContexts,200                             baseRawType: baseRawType,201                             rawTypeRepository: rawTypeRepository,202                             typealiasRepository: typealiasRepository)203    self.selfConformanceTypes = allSelfConformanceTypes204    self.allSelfConformanceTypeNames = allSelfConformanceTypeNames205    206    if let inheritedPrimaryType =207      inheritedTypes.sorted() // e.g. `protocol MyProtocol: ClassOnlyProtocol`208        .first(where: { $0.primarySelfConformanceType != nil }) ??209      allSelfConformanceTypes.sorted() // e.g. `protocol MyProtocol where Self: ClassOnlyProtocol`210        .first(where: { $0.primarySelfConformanceType != nil }),211      let primarySelfConformanceType = inheritedPrimaryType.primarySelfConformanceType,212      let primarySelfConformanceTypeName = inheritedPrimaryType.primarySelfConformanceTypeName {213      214      self.primarySelfConformanceType = primarySelfConformanceType215      self.primarySelfConformanceTypeName = primarySelfConformanceTypeName216    } else if let primaryType = allSelfConformanceTypes.sorted()217      .first(where: { $0.kind == .class }) {218      self.primarySelfConformanceType = primaryType219      self.primarySelfConformanceTypeName = MockableType220        .specializedSelfConformanceTypeName(primaryType,221                                            specializationContexts: specializationContexts,222                                            moduleNames: moduleNames,223                                            baseRawType: baseRawType,224                                            rawTypeRepository: rawTypeRepository,225                                            typealiasRepository: typealiasRepository)226    } else {227      self.primarySelfConformanceType = nil228      self.primarySelfConformanceTypeName = nil229    }230    231    self.subclassesExternalType = subclassesExternalType || conformsToExternalType232    self.methods = methods233    self.variables = variables234    235    var methodsCount = [Method.Reduced: UInt]()236    methods.forEach({ methodsCount[Method.Reduced(from: $0), default: 0] += 1 })237    self.methodsCount = methodsCount238    239    self.genericTypes = genericTypes240    self.whereClauses = Set(whereClauses)241    242    // Parse any containing preprocessor macros.243    if let offset = baseRawType.dictionary[SwiftDocKey.offset.rawValue] as? Int64 {244      self.compilationDirectives = baseRawType.parsedFile.compilationDirectives.filter({245        $0.range.contains(offset)246      })247    } else {248      self.compilationDirectives = []249    }250    251    // Check if any of the members have `Self` constraints.252    self.hasSelfConstraint = whereClauses.contains(where: { $0.hasSelfConstraint })253      || methods.contains(where: { $0.hasSelfConstraint })254      || variables.contains(where: { $0.hasSelfConstraint })255      || genericTypes.contains(where: { $0.hasSelfConstraint })256    257    if baseRawType.parsedFile.shouldMock {258      self.sortableIdentifier = [259        self.name,260        self.genericTypes.map({ "\($0.name):\($0.constraints)" }).joined(separator: ","),261        self.whereClauses.map({ "\($0)" }).joined(separator: ",")262      ].joined(separator: "|")263    } else {264      self.sortableIdentifier = name265    }266  }267  268  private static func parseDeclaredTypes(rawTypes: [RawType],269                                         baseRawType: RawType,270                                         moduleNames: [String],271                                         rawTypeRepository: RawTypeRepository,272                                         typealiasRepository: TypealiasRepository)273    -> (methods: Set<Method>, variables: Set<Variable>) {274      var methods = Set<Method>()275      var variables = Set<Variable>()276      for rawType in rawTypes {277        guard let substructure = rawType.dictionary[SwiftDocKey.substructure.rawValue]278          as? [StructureDictionary] else { continue }279        // Cannot override declarations in extensions as they are statically defined.280        guard rawType.kind != .extension else { continue }281        for structure in substructure {282          if let method = Method(from: structure,...

1import Foundation2import SwiftSyntax3class MySyntaxVisitor: SyntaxVisitor {4    override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {5        print("Struct: \(node.identifier.text)")6    }7    override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {8        print("Class: \(node.identifier.text)")9    }10}11let sourceFile = URL(fileURLWithPath: "/Users/rajesh/Downloads/1.swift")12let sourceFileSyntax = try SyntaxTreeParser.parse(sourceFile)13let visitor = MySyntaxVisitor()14sourceFileSyntax.walk(visitor)15import Foundation16import SwiftSyntax17class MySyntaxVisitor: SyntaxVisitor {18    override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {19        print("Struct: \(node.identifier.text)")20    }21    override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {22        print("Class: \(node.identifier.text)")23    }24}25let sourceFile = URL(fileURLWithPath: "/Users/rajesh/Downloads/2.swift")26let sourceFileSyntax = try SyntaxTreeParser.parse(sourceFile)27let visitor = MySyntaxVisitor()28sourceFileSyntax.walk(visitor)29import Foundation30import SwiftSyntax31class MySyntaxVisitor: SyntaxVisitor {32    override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {33        print("Struct: \(node.identifier.text)")34    }35    override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {36        print("Class: \(node.identifier.text)")37    }38}39let sourceFile = URL(fileURLWithPath: "/Users/rajesh/Downloads/3.swift")40let sourceFileSyntax = try SyntaxTreeParser.parse(sourceFile)41let visitor = MySyntaxVisitor()42sourceFileSyntax.walk(visitor)43import Foundation44import SwiftSyntax45class MySyntaxVisitor: SyntaxVisitor {46    override func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {47        print("Struct: \(node

1func parseDeclaredTypes(conformance: Conformance) {2    for type in conformance.declaredTypes {3        print(type)4    }5}6func parseDeclaredTypes(conformance: Conformance) {7    for type in conformance.declaredTypes {8        print(type)9    }10}11func parseDeclaredTypes(conformance: Conformance) {12    for type in conformance.declaredTypes {13        print(type)14    }15}16func parseDeclaredTypes(conformance: Conformance) {17    for type in conformance.declaredTypes {18        print(type)19    }20}21func parseDeclaredTypes(conformance: Conformance) {22    for type in conformance.declaredTypes {23        print(type)24    }25}26func parseDeclaredTypes(conformance: Conformance) {27    for type in conformance.declaredTypes {28        print(type)29    }30}31func parseDeclaredTypes(conformance: Conformance) {32    for type in conformance.declaredTypes {33        print(type)34    }35}36func parseDeclaredTypes(conformance: Conformance) {37    for type in conformance.declaredTypes {38        print(type)39    }40}41func parseDeclaredTypes(conformance: Conformance) {42    for type in conformance.declaredTypes {43        print(type)44    }45}46func parseDeclaredTypes(conformance: Conformance) {47    for type in conformance.declaredTypes {48        print(type)49    }50}51func parseDeclaredTypes(conformance: Con

1protocol P {2func foo() -> Int3}4func bar<T: P>(_: T) {}5}6import 17extension A: P {8func foo() -> Int { return 0 }9}10import 111import 212bar(A())13import 114import 215bar(A())16import 117import 218bar(A())19import 120import 221bar(A())22import 123import 224bar(A())25import 126import 227bar(A())28import 129import 230bar(A())31import 132import 233bar(A())34import 135import 236bar(A())37import 138import 239bar(A())40import 141import 242bar(A())43import 144import 245bar(A())46import 147import 248bar(A())49import 150import 251bar(A())52import 153import 254bar(A())55import 156import 257bar(A())58import 159import 260bar(A())61import 162import 263bar(A())64import 165import 266bar(A())67import 168import 269bar(A())70import 171import 272bar(A())73import 174import 275bar(A())76import 177import 278bar(A())79import 180import 281bar(A())82import 183import 284bar(A

1import Foundation2class ParseJson {3    func parseJsonFile() {4        if let path = Bundle.main.path(forResource: "test", ofType: "json") {5            do {6                let data = try Data(contentsOf: URL(fileURLWithPath: path), options: .mappedIfSafe)7                let jsonResult = try JSONSerialization.jsonObject(with: data, options: .mutableLeaves)8                if let jsonResult = jsonResult as? Dictionary<String, AnyObject>, let result = jsonResult["result"] as? Dictionary<String, AnyObject>, let conformance = result["conformance"] as? Dictionary<String, AnyObject> {9                    let parse = ParseDeclaredTypes()10                    parse.parseDeclaredTypes(declaredTypes: conformance["declaredTypes"] as? Dictionary<String, AnyObject>)11                }12            } catch {13            }14        }15    }16}17class ParseDeclaredTypes {18    func parseDeclaredTypes(declaredTypes: Dictionary<String, AnyObject>?) {19        if let declaredTypes = declaredTypes {20            for (key, value) in declaredTypes {21                if key == "Swift.Int" {22                    if let value = value as? Dictionary<String, AnyObject>, let conformingTypes = value["conformingTypes"] as? Array<String> {23                        print("Swift.Int conforming types:")24                        for type in conformingTypes {25                            print(type)26                        }27                    }28                }29            }30        }31    }32}33class ParseJson {34    func parseJsonFile() {35        if let path = Bundle.main.path(forResource: "test", ofType: "json") {36            do {37                let data = try Data(contentsOf: URL(fileURLWithPath: path), options: .mappedIfSafe)38                let jsonResult = try JSONSerialization.jsonObject(with: data, options: .mutableLeaves)