#270\" style=\"filled\" fillcolor=\"#e0e0e0\" color=\"#000000\"];\n 269 -> 270 [label=\"_invalidated\" color=\"#000000\" eid=\"486\"];\n}\n"
},
{
"path": "Contents/Resources/log.html",
"content": "\nThis area is fully editable and can be annotated.\n
\n"
},
{
"path": "LICENSE",
"content": "MIT License\n\nCopyright (c) 2021 John Holdsworth\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "Package.swift",
"content": "// swift-tools-version:5.2\n// The swift-tools-version declares the minimum version of Swift required to build this package.\n//\n// Repo: https://github.com/johnno1962/HotReloading\n// $Id: //depot/HotReloading/Package.swift#205 $\n//\n\nimport PackageDescription\nimport Foundation\n\n// This means of locating the IP address of developer's\n// Mac has been replaced by a multicast implementation.\n// If the multicast implementation fails to connect,\n// clone the HotReloading project and hardcode the IP\n// address of your Mac into the hostname value below.\n// Then drag the clone onto your project to have it\n// take precedence over the configured version.\nvar hostname = Host.current().name ?? \"localhost\"\n// hostname = \"192.168.0.243\" // for example\n\nlet simulateDlopenOnDevice = false\n\nlet package = Package(\n name: \"HotReloading\",\n platforms: [.macOS(\"10.12\"), .iOS(\"10.0\"), .tvOS(\"10.0\")],\n products: [\n .library(name: \"HotReloading\", targets: [\"HotReloading\"]),\n .library(name: \"HotReloadingGuts\", targets: [\"HotReloadingGuts\"]),\n .library(name: \"injectiondGuts\", targets: [\"injectiondGuts\"]),\n .executable(name: \"injectiond\", targets: [\"injectiond\"]),\n ],\n dependencies: [\n .package(url: \"https://github.com/johnno1962/SwiftTrace\",\n .upToNextMinor(from: \"8.6.1\")),\n .package(name: \"SwiftRegex\",\n url: \"https://github.com/johnno1962/SwiftRegex5\",\n .upToNextMinor(from: \"6.1.2\")),\n .package(url: \"https://github.com/johnno1962/XprobePlugin\",\n .upToNextMinor(from: \"2.9.10\")),\n .package(name: \"RemotePlugin\",\n url: \"https://github.com/johnno1962/Remote\",\n .upToNextMinor(from: \"2.3.5\")),\n .package(url: \"https://github.com/johnno1962/ProfileSwiftUI\",\n .upToNextMinor(from: \"1.1.3\")),\n// .package(url: \"https://github.com/johnno1962/DLKit\",\n// .upToNextMinor(from: \"1.2.1\")),\n ] + (simulateDlopenOnDevice ? [\n .package(url: \"https://github.com/johnno1962/InjectionScratch\",\n .upToNextMinor(from: \"1.2.13\"))] : []),\n targets: [\n .target(name: \"HotReloading\", dependencies: [\"HotReloadingGuts\",\n .product(name: \"SwiftTraceD\", package: \"SwiftTrace\"),\n .product(name: \"Xprobe\", package: \"XprobePlugin\"),\n .product(name: \"SwiftRegex\", package: \"SwiftRegex\"),\n \"ProfileSwiftUI\" /*, \"DLKit\",\n */] + (simulateDlopenOnDevice ? [\"InjectionScratch\"] : [])\n /*, linkerSettings: [.unsafeFlags([\n \"-Xlinker\", \"-interposable\", \"-undefined\", \"dynamic_lookup\"])]*/),\n .target(name: \"HotReloadingGuts\",\n cSettings: [.define(\"DEVELOPER_HOST\", to: \"\\\"\\(hostname)\\\"\")]),\n .target(name: \"injectiondGuts\"),\n .target(name: \"injectiond\", dependencies: [\"HotReloadingGuts\", \"injectiondGuts\",\n .product(name: \"SwiftRegex\", package: \"SwiftRegex\"),\n .product(name: \"XprobeUI\", package: \"XprobePlugin\"),\n .product(name: \"RemoteUI\", package: \"RemotePlugin\")],\n swiftSettings: [.define(\"INJECTION_III_APP\")])],\n cxxLanguageStandard: .cxx11\n)\n"
},
{
"path": "README.md",
"content": "# Yes, HotReloading for Swift, Objective-C & C++!\n\nNote: While this was once a way of using the InjectionIII.app on real devices\nand for its development you would not normally need to use this repo any \nmore as you can use the pre-built bundles using the `copy_bundle.sh` \nscript. It has also been largely superseded by the newer and simpler \n[InjectionNext](https://github.com/johnno1962/InjectionNext) project.\nYou should only add the HotReloading product to your main target.\n\nThis project is the [InjectionIII](https://github.com/johnno1962/InjectionIII) app\nfor live code updates available as a Swift Package. i.e.:\n\n\n\nThen, you can inject function implementations without having to rebuild your app...\n\n\nTo try out an example project that is already set-up, clone this fork of\n[SwiftUI-Kit](https://github.com/johnno1962/SwiftUI-Kit).\n\nTo use on your project, add this repo as a Swift Package and add \n\"Other Linker Flags\": -Xlinker -interposable. You no longer need\nto add a \"Run Script\" build phase. If want to inject on a device, \nsee the notes below on how to configure the InjectionIII app.\nNote however, on an M1/M2 Mac this project only works with \nan iOS/tvOS 14 or later simulator. Also, due to a quirk of how\nXcode how enables a DEBUG build of Swift Packages, your \n\"configuration\" needs to contain the string \"Debug\".\n\n***Remember not to release your app with this package configured.***\n\nYou should see a message that the app is watching for source file \nchanges in your home directory. You can change this scope by\nadding comma separated list in the environment variable\n`INJECTION_DIRECTORIES`. Should you want to connect to the \nInjectionIII.app when using the simulator, add the environment \nvariable `INJECTION_DAEMON` to your scheme.\n\nConsult the README of the [InjectionIII](https://github.com/johnno1962/InjectionIII)\nproject for more information in particular how to use it to inject `SwiftUI` using the\n[HotSwiftUI](https://github.com/johnno1962/HotSwiftUI) protocol extension.\n\n### HotReloading using VSCode\n\nIt's possible to use HotReloading from inside the VSCode editor and realise a\nform of \"VScode Previews\". Consult [this project](https://github.com/markst/hotreloading-vscode-ios) for the setup required.\n\n### Device Injection\n\nThis version of the HotReloading project and it's dependencies now support\ninjection on a real iOS or tvOS device. \n\nDevice injection now connects to the [InjectionIII.app](https://github.com/johnno1962/InjectionIII)\n([github release](https://github.com/johnno1962/InjectionIII/releases)\n4.6.0 or above) and requires you type the following commands into a Terminal \nthen restart the app to opt into receiving remote connections from a device:\n\n $ rm ~/Library/Containers/com.johnholdsworth.InjectionIII/Data/Library/Preferences/com.johnholdsworth.InjectionIII.plist\n $ defaults write com.johnholdsworth.InjectionIII deviceUnlock any\n \nNote, if you've used the App Store version of InjectionIII in the past,\nthe binary releases have a different preferences file and the two can\nget confused and prevent writing this preference from taking effect.\nThis is why the first `rm` command above can be necessary. If your\ndevice doesn't connect check the app is listening on port `8899`:\n\n```\n% netstat -an | grep LIST | grep 88\ntcp4 0 0 127.0.0.1.8898 *.* LISTEN\ntcp4 0 0 *.8899 *.* LISTEN\n```\nIf your device still doesn't connect either add an `INJECTION_HOST`\nenvironment variable to your scheme containg the WiFi IP address of\nthe host you're running the InjectionIII.app on or clone this project and \ncode your mac's IP address into the `hostname` variable in Package.swift.\nThen, drag the clone onto your project to have it take the place of the\nconfigured Swift Package as outlined in [these instructions](https://developer.apple.com/documentation/xcode/editing-a-package-dependency-as-a-local-package).\n\nNote: as the HotReloading package needs to connect a network\nsocket to your Mac to receive commands and new versions of code, expect\na message the first time you run your app after adding the package\nasking you to \"Trust\" that your app should be allowed to do this.\nLikewise, at the Mac end (as the InjectionIII app needs to open\na network port to accept this connection) you may be prompted for\npermission if you have the macOS firewall turned on.\n\nFor `SwiftUI` you can force screen updates by following the conventions \noutlined in the [HotSwiftUI](https://github.com/johnno1962/HotSwiftUI) \nproject then you can experience something like \"Xcode Previews\", except \nfor a fully functional app on an actual device!\n\n### Vapor injection\n\nTo use injection with Vapor web server, it is now possible to just\ndownload the [InjectionIII.app](https://github.com/johnno1962/InjectionIII)\nand add the following line to be called as the server configures\n(when running Vapor from inside Xcode): \n\n```\n #if DEBUG && os(macOS)\n Bundle(path: \"/Applications/InjectionIII.app/Contents/Resources/macOSInjection.bundle\")?.load()\n #endif\n```\nIt will also be necessary to add the following argument to your targets:\n\n ```\n linkerSettings: [.unsafeFlags([\"-Xlinker\", \"-interposable\"],\n .when(platforms: [.macOS], configuration: .debug))]\n ```\nAs an alternative, you can add this Swift package as a dependency to Vapor's \nPackage.swift of the \"App\" target.\n\n### Thanks to...\n\nThe App Tracing functionality uses the [OliverLetterer/imp_implementationForwardingToSelector](https://github.com/OliverLetterer/imp_implementationForwardingToSelector) trampoline implementation\nvia the [SwiftTrace](https://github.com/johnno1962/SwiftTrace) project under an MIT license.\n\nSwiftTrace uses the very handy [https://github.com/facebook/fishhook](https://github.com/facebook/fishhook)\nas an alternative to the dyld_dynamic_interpose dynamic loader private api. See the\n project source and header file included in the framework for licensing details.\n\nThe [\"Remote\"](https://github.com/johnno1962/Remote) server in this project which\nallows you to capture videos from your device includes code adapted from\n[acj/TimeLapseBuilder-Swift](https://github.com/acj/TimeLapseBuilder-Swift)\n\nThis release includes a very slightly modified version of the excellent\n[canviz](https://code.google.com/p/canviz/) library to render \"dot\" files\nin an HTML canvas which is subject to an MIT license. The changes are to pass\nthrough the ID of the node to the node label tag (line 212), to reverse\nthe rendering of nodes and the lines linking them (line 406) and to\nstore edge paths so they can be coloured (line 66 and 303) in \"canviz-0.1/canviz.js\".\n\nIt also includes [CodeMirror](http://codemirror.net/) JavaScript editor for\nthe code to be evaluated in the Xprobe browser under an MIT license.\n\n$Date: 2025/08/03 $\n"
},
{
"path": "Sources/HotReloading/DeviceInjection.swift",
"content": "//\n// DeviceInjection.swift\n//\n// Created by John Holdsworth on 17/03/2022.\n// Copyright © 2022 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/DeviceInjection.swift#44 $\n//\n// Code specific to injecting on an actual device.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\n#if !targetEnvironment(simulator) && SWIFT_PACKAGE && canImport(InjectionScratch)\n#if SWIFT_PACKAGE\nimport SwiftRegex\n#endif\n\nextension SwiftInjection {\n\n /// Emulate remaining functions of the dynamic linker.\n /// - Parameter pseudoImage: last image read into memory\n public class func onDeviceSpecificProcessing(\n for pseudoImage: MachImage, _ sweepClasses: [AnyClass]) {\n // register types, protocols, conformances...\n var section_size: UInt64 = 0\n for (section, regsiter) in [\n (\"types\", \"swift_registerTypeMetadataRecords\"),\n (\"protos\", \"swift_registerProtocols\"),\n (\"proto\", \"swift_registerProtocolConformances\")] {\n if let section_start =\n getsectdatafromheader_64(autoBitCast(pseudoImage),\n SEG_TEXT, \"__swift5_\"+section, §ion_size),\n section_size != 0, let call: @convention(c)\n (UnsafeRawPointer, UnsafeRawPointer) -> Void =\n autoBitCast(dlsym(SwiftMeta.RTLD_DEFAULT, regsiter)) {\n call(section_start, section_start+Int(section_size))\n }\n }\n // Redirect symbolic type references to main bundle\n reverse_symbolics(pseudoImage)\n // Initialise offsets to ivars\n adjustIvarOffsets(in: pseudoImage)\n // Fixup references to Objective-C classes\n fixupObjcClassReferences(in: pseudoImage)\n // Fix Objective-C messages to super\n var supersSize: UInt64 = 0\n if let injectedClass = sweepClasses.first,\n let supersSection: UnsafeMutablePointer = autoBitCast(\n getsectdatafromheader_64(autoBitCast(pseudoImage), SEG_DATA,\n \"__objc_superrefs\", &supersSize)), supersSize != 0 {\n supersSection[0] = injectedClass\n }\n // Populate \"l_got.*\" descriptor references\n bindDescriptorReferences(in: pseudoImage)\n }\n\n struct ObjcClassMetaData {\n var metaClass: AnyClass?\n var metaData: UnsafeMutablePointer? {\n return autoBitCast(metaClass)\n }\n var superClass: AnyClass?\n var superData: UnsafeMutablePointer? {\n return autoBitCast(superClass)\n }\n var methodCache: UnsafeMutableRawPointer\n var bits: uintptr_t\n var data: UnsafeMutablePointer?\n }\n\n public class func fillinObjcClassMetadata(in pseudoImage: MachImage) {\n\n func getClass(_ sym: UnsafePointer)\n -> UnsafeMutablePointer? {\n return autoBitCast(dlsym(SwiftMeta.RTLD_DEFAULT, sym))\n }\n\n var sectionSize: UInt64 = 0\n let info = getsectdatafromheader_64(autoBitCast(pseudoImage),\n SEG_DATA, \"__objc_imageinfo\", §ionSize)\n let metaNSObject = getClass(\"OBJC_CLASS_$_NSObject\")\n let emptyCache = dlsym(SwiftMeta.RTLD_DEFAULT, \"_objc_empty_cache\")!\n\n func fillin(newClass: UnsafeRawPointer, symname: UnsafePointer) {\n let metaData:\n UnsafeMutablePointer = autoBitCast(newClass)\n if let oldClass = getClass(symname) {\n metaData.pointee.methodCache = emptyCache\n metaData.pointee.superClass = oldClass.pointee.superClass\n metaData.pointee.metaData?.pointee.methodCache = emptyCache\n metaData.pointee.metaData?.pointee.metaClass =\n metaNSObject?.pointee.metaClass\n metaData.pointee.metaData?.pointee.superClass =\n oldClass.pointee.metaClass // should be super of metaclass..\n if registerClasses, #available(macOS 10.10, iOS 8.0, tvOS 9.0, *) {\n detail(\"\\(newClass): \\(metaData.pointee) -> \" +\n \"\\((metaData.pointee.metaData ?? metaData).pointee)\")\n// _objc_realizeClassFromSwift(autoBitCast(aClass), oldClass)\n objc_readClassPair(autoBitCast(newClass), autoBitCast(info))\n } else {\n // Fallback on earlier versions\n }\n }\n }\n\n SwiftTrace.forAllClasses(bundlePath: searchLastLoaded()) {\n (aClass, stop) in\n var info = Dl_info()\n let address: UnsafeRawPointer = autoBitCast(aClass)\n if fast_dladdr(address, &info) != 0, let symname = info.dli_sname {\n fillin(newClass: address, symname: symname)\n }\n }\n }\n\n // Used to enumerate methods\n // on an \"unrealised\" class.\n struct ObjcMethodMetaData {\n let name: UnsafePointer\n let type: UnsafePointer\n let impl: IMP\n }\n\n struct ObjcMethodListMetaData {\n let flags: Int32, methodCount: Int32\n var firstMethod: ObjcMethodMetaData\n }\n\n struct ObjcReadOnlyMetaData {\n let skip: (Int32, Int32, Int32, Int32) = (0, 0, 0, 0)\n let names: (UnsafeRawPointer?, UnsafePointer?)\n let methods: UnsafeMutablePointer?\n }\n\n public class func onDevice(swizzle oldClass: AnyClass,\n from newClass: AnyClass) -> Int {\n var swizzled = 0\n let metaData: UnsafePointer = autoBitCast(newClass)\n if !class_isMetaClass(oldClass), // class methods...\n let metaClass = metaData.pointee.metaClass,\n let metaOldClass = object_getClass(oldClass) {\n swizzled += onDevice(swizzle: metaOldClass, from: metaClass)\n }\n\n let swiftBits: uintptr_t = 0x3\n guard let roData: UnsafePointer =\n autoBitCast(autoBitCast(metaData.pointee.data) & ~swiftBits),\n let methodInfo = roData.pointee.methods else { return swizzled }\n\n withUnsafePointer(to: &methodInfo.pointee.firstMethod) {\n methods in\n for i in 0 ..< Int(methodInfo.pointee.methodCount) {\n let selector = sel_registerName(methods[i].name)\n let method = class_getInstanceMethod(oldClass, selector)\n let existing = method.flatMap { method_getImplementation($0) }\n traceAndReplace(existing, replacement: autoBitCast(methods[i].impl),\n objcMethod: method, objcClass: newClass) {\n (replacement: IMP) -> String? in\n if class_replaceMethod(oldClass, selector, replacement,\n methods[i].type) != replacement {\n swizzled += 1\n return \"Swizzled\"\n }\n return nil\n }\n }\n }\n\n return swizzled\n }\n\n public class func adjustIvarOffsets(in pseudoImage: MachImage) {\n var ivarOffsetPtr: UnsafeMutablePointer!\n\n // Objective-C source version\n pseudoImage.symbols(withPrefix: \"_OBJC_IVAR_$_\") {\n (address, symname, suffix) in\n if let classname = strdup(suffix),\n var ivarname = strchr(classname, Int32(UInt8(ascii: \".\"))) {\n ivarname[0] = 0\n ivarname += 1\n\n if let oldClass = objc_getClass(classname) as? AnyClass,\n let ivar = class_getInstanceVariable(oldClass, ivarname) {\n ivarOffsetPtr = autoBitCast(address)\n ivarOffsetPtr.pointee = ivar_getOffset(ivar)\n detail(String(cString: classname)+\".\" +\n String(cString: ivarname) +\n \" offset: \\(ivarOffsetPtr.pointee)\")\n }\n\n free(classname)\n } else {\n log(\"⚠️ Could not parse ivar: \\(String(cString: symname))\")\n }\n }\n\n // Swift source version\n findHiddenSwiftSymbols(searchLastLoaded(), \"Wvd\", .any) {\n (address, symname, _, _) -> Void in\n if let fieldInfo = SwiftMeta.demangle(symbol: symname),\n let (classname, ivarname): (String, String) =\n fieldInfo[#\"direct field offset for (\\S+)\\.\\(?(\\w+) \"#],\n let oldClass = objc_getClass(classname) as? AnyClass,\n let ivar = class_getInstanceVariable(oldClass, ivarname),\n get_protection(autoBitCast(address)) & VM_PROT_WRITE != 0 {\n ivarOffsetPtr = autoBitCast(address)\n ivarOffsetPtr.pointee = ivar_getOffset(ivar)\n detail(classname+\".\"+ivarname +\n \" direct offset: \\(ivarOffsetPtr.pointee)\")\n } else {\n log(\"⚠️ Could not parse ivar: \\(String(cString: symname))\")\n }\n }\n }\n\n /// Fixup references to Objective-C classes on device\n public class func fixupObjcClassReferences(in pseudoImage: MachImage) {\n var sectionSize: UInt64 = 0\n if let classNames = objcClassRefs as? [String], classNames.first != \"\",\n let classRefsSection: UnsafeMutablePointer = autoBitCast(\n getsectdatafromheader_64(autoBitCast(pseudoImage),\n SEG_DATA, \"__objc_classrefs\", §ionSize)) {\n let nClassRefs = Int(sectionSize)/MemoryLayout.size\n let objcClasses = classNames.compactMap {\n return dlsym(SwiftMeta.RTLD_DEFAULT, \"OBJC_CLASS_$_\"+$0)\n }\n if nClassRefs == objcClasses.count {\n for i in 0 ..< nClassRefs {\n classRefsSection[i] = autoBitCast(objcClasses[i])\n }\n } else {\n log(\"⚠️ Number of class refs \\(nClassRefs) does not equal \\(classNames)\")\n }\n }\n }\n\n /// Populate \"l_got.*\" external references to \"descriptors\"\n /// - Parameter pseudoImage: lastLoadedImage\n public class func bindDescriptorReferences(in pseudoImage: MachImage) {\n if let descriptorSyms = descriptorRefs as? [String],\n descriptorSyms.first != \"\" {\n var forces: UnsafeRawPointer?\n let forcePrefix = \"__swift_FORCE_LOAD_$_\"\n let forcePrefixLen = strlen(forcePrefix)\n fast_dlscan(pseudoImage, .any, { symname in\n return strncmp(symname, forcePrefix, forcePrefixLen) == 0\n }) { value, symname, _, _ in\n forces = value\n }\n\n if var descriptorRefs:\n UnsafeMutablePointer = autoBitCast(forces) {\n for descriptorSym in descriptorSyms {\n descriptorRefs = descriptorRefs.advanced(by: 1)\n if let value = dlsym(SwiftMeta.RTLD_DEFAULT, descriptorSym),\n descriptorRefs.pointee == nil {\n descriptorRefs.pointee = value\n } else {\n detail(\"⚠️ Could not bind \" + describeImageSymbol(descriptorSym))\n }\n }\n } else {\n log(\"⚠️ Could not locate descriptors section\")\n }\n }\n }\n}\n#endif\n#endif\n"
},
{
"path": "Sources/HotReloading/DynamicCast.swift",
"content": "//\n// DynamicCast.swift\n// InjectionIII\n//\n// Created by John Holdsworth on 02/24/2021.\n// Copyright © 2021 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/DynamicCast.swift#12 $\n//\n// Dynamic casting in an \"as?\" expression to a type that has been injected.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n\npublic func injection_dynamicCast(inp: UnsafeRawPointer,\n out: UnsafeMutablePointer,\n from: Any.Type, to: Any.Type, size: size_t) -> Bool {\n let toName = _typeName(to)\n// print(\"HERE \\(inp) \\(out) \\(_typeName(from)) \\(toName) \\(size)\")\n let to = toName.hasPrefix(\"__C.\") ? to :\n SwiftMeta.lookupType(named: toName, protocols: true) ?? to\n return DynamicCast.original_dynamicCast?(inp, out,\n autoBitCast(from), autoBitCast(to), size) ?? false\n}\n\nclass DynamicCast {\n\n typealias injection_dynamicCast_t = @convention(c)\n (_ inp: UnsafeRawPointer,\n _ out: UnsafeMutablePointer,\n _ from: UnsafeRawPointer, _ to: UnsafeRawPointer,\n _ size: size_t) -> Bool\n\n static let swift_dynamicCast = strdup(\"swift_dynamicCast\")!\n static let original_dynamicCast: injection_dynamicCast_t? =\n autoBitCast(dlsym(SwiftMeta.RTLD_DEFAULT, swift_dynamicCast))\n static var hooked_dynamicCast: UnsafeMutableRawPointer? = {\n let module = _typeName(DynamicCast.self)\n .components(separatedBy: \".\")[0]\n return dlsym(SwiftMeta.RTLD_DEFAULT,\n \"$s\\(module.count)\\(module)\" +\n \"21injection_dynamicCast\" +\n \"3inp3out4from2to4sizeSbSV_\" +\n \"SpySVGypXpypXpSitF\")\n }()\n\n static var rebinds = original_dynamicCast != nil &&\n hooked_dynamicCast != nil ? [\n rebinding(name: swift_dynamicCast,\n replacement: hooked_dynamicCast!,\n replaced: nil)] : []\n\n static var hook_appDynamicCast: Void = {\n appBundleImages { imageName, header, slide in\n rebind_symbols_image(autoBitCast(header), slide,\n &rebinds, rebinds.count)\n }\n }()\n\n static func hook_lastInjected() {\n _ = DynamicCast.hook_appDynamicCast\n let lastLoaded = _dyld_image_count()-1\n rebind_symbols_image(\n UnsafeMutableRawPointer(mutating: lastPseudoImage() ??\n _dyld_get_image_header(lastLoaded)),\n lastPseudoImage() != nil ? 0 :\n _dyld_get_image_vmaddr_slide(lastLoaded),\n &rebinds, rebinds.count)\n }\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/FileWatcher.swift",
"content": "//\n// FileWatcher.swift\n// InjectionIII\n//\n// Created by John Holdsworth on 08/03/2015.\n// Copyright (c) 2015 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/FileWatcher.swift#49 $\n//\n// Started out as an abstraction to watch files under a directory.\n// \"Enhanced\" to extract the last modified build log directory by\n// backdating the event stream to just before the app launched.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\n#if targetEnvironment(simulator) && !APP_SANDBOXED || os(macOS)\nimport Foundation\n\npublic class FileWatcher: NSObject {\n public typealias InjectionCallback = (_ filesChanged: NSArray, _ ideProcPath: String) -> Void\n static var INJECTABLE_PATTERN = try! NSRegularExpression(\n pattern: \"[^~]\\\\.(mm?|cpp|swift|storyboard|xib)$\")\n\n static let logsPref = \"HotReloadingBuildLogsDir\"\n static var derivedLog =\n UserDefaults.standard.string(forKey: logsPref) {\n didSet {\n UserDefaults.standard.set(derivedLog, forKey: logsPref)\n }\n }\n\n var initStream: ((FSEventStreamEventId) -> Void)!\n var eventsStart =\n FSEventStreamEventId(kFSEventStreamEventIdSinceNow)\n #if SWIFT_PACKAGE\n var eventsToBackdate: UInt64 = 10_000\n #else\n var eventsToBackdate: UInt64 = 50_000\n #endif\n\n var fileEvents: FSEventStreamRef! = nil\n var callback: InjectionCallback\n var context = FSEventStreamContext()\n\n @objc public init(roots: [String], callback: @escaping InjectionCallback,\n runLoop: CFRunLoop? = nil) {\n self.callback = callback\n super.init()\n #if os(macOS)\n context.info = unsafeBitCast(self, to: UnsafeMutableRawPointer.self)\n #else\n guard let FSEventStreamCreate = FSEventStreamCreate else {\n fatalError(\"Could not locate FSEventStreamCreate\")\n }\n #endif\n initStream = { [weak self] since in\n guard let self = self else { return }\n let fileEvents = FSEventStreamCreate(kCFAllocatorDefault,\n { (streamRef: FSEventStreamRef,\n clientCallBackInfo: UnsafeMutableRawPointer?,\n numEvents: Int, eventPaths: UnsafeMutableRawPointer,\n eventFlags: UnsafePointer,\n eventIds: UnsafePointer) in\n #if os(macOS)\n let watcher = unsafeBitCast(clientCallBackInfo, to: FileWatcher.self)\n #else\n guard let watcher = watchers[streamRef] else { return }\n #endif\n // Check that the event flags include an item renamed flag, this helps avoid\n // unnecessary injection, such as triggering injection when switching between\n // files in Xcode.\n for i in 0 ..< numEvents {\n let flag = Int(eventFlags[i])\n if (flag & (kFSEventStreamEventFlagItemRenamed | kFSEventStreamEventFlagItemModified)) != 0 {\n let changes = unsafeBitCast(eventPaths, to: NSArray.self)\n if CFRunLoopGetCurrent() != CFRunLoopGetMain() {\n return watcher.filesChanged(changes: changes)\n }\n DispatchQueue.main.async {\n watcher.filesChanged(changes: changes)\n }\n return\n }\n }\n },\n &self.context, roots as CFArray, since, 0.1,\n FSEventStreamCreateFlags(kFSEventStreamCreateFlagUseCFTypes |\n kFSEventStreamCreateFlagFileEvents))!\n #if !os(macOS)\n watchers[fileEvents] = self\n #endif\n FSEventStreamScheduleWithRunLoop(fileEvents, runLoop ?? CFRunLoopGetMain(),\n \"kCFRunLoopDefaultMode\" as CFString)\n _ = FSEventStreamStart(fileEvents)\n self.fileEvents = fileEvents\n }\n initStream(eventsStart)\n }\n\n func filesChanged(changes: NSArray) {\n var changed = Set()\n #if !INJECTION_III_APP\n let eventId = FSEventStreamGetLatestEventId(fileEvents)\n if eventId != kFSEventStreamEventIdSinceNow &&\n eventsStart == kFSEventStreamEventIdSinceNow {\n eventsStart = eventId\n FSEventStreamStop(fileEvents)\n initStream(max(0, eventsStart-eventsToBackdate))\n return\n }\n #endif\n\n for path in changes {\n guard var path = path as? String else { continue }\n #if !INJECTION_III_APP\n if path.hasSuffix(\".xcactivitylog\") &&\n path.contains(\"/Logs/Build/\") {\n Self.derivedLog = path\n }\n if eventId <= eventsStart { continue }\n #endif\n\n if Self.INJECTABLE_PATTERN.firstMatch(in: path,\n range: NSMakeRange(0, path.utf16.count)) != nil &&\n path.range(of: \"DerivedData/|InjectionProject/|.DocumentRevisions-|@__swiftmacro_|main.mm?$\",\n options: .regularExpression) == nil {\n if let absolute = try? URL(fileURLWithPath: path)\n .resourceValues(forKeys: [.canonicalPathKey])\n .canonicalPath {\n path = absolute\n }\n changed.insert(path)\n }\n }\n\n if changed.count != 0 {\n var path = \"\"\n #if os(macOS)\n if let application = NSWorkspace.shared.frontmostApplication {\n path = getProcPath(pid: application.processIdentifier)\n }\n #endif\n callback(Array(changed) as NSArray, path)\n }\n }\n\n #if os(macOS)\n deinit {\n FSEventStreamStop(fileEvents)\n FSEventStreamInvalidate(fileEvents)\n FSEventStreamRelease(fileEvents)\n #if DEBUG\n NSLog(\"\\(self).deinit()\")\n #endif\n }\n\n func getProcPath(pid: pid_t) -> String {\n let pathBuffer = UnsafeMutablePointer.allocate(capacity: Int(MAXPATHLEN))\n defer {\n pathBuffer.deallocate()\n }\n proc_pidpath(pid, pathBuffer, UInt32(MAXPATHLEN))\n let path = String(cString: pathBuffer)\n return path\n }\n #endif\n}\n\n#if !os(macOS) // Yes, this api is available inside the simulator...\ntypealias FSEventStreamRef = OpaquePointer\ntypealias ConstFSEventStreamRef = OpaquePointer\nstruct FSEventStreamContext {\n var version: CFIndex = 0\n var info: UnsafeRawPointer?\n var retain: UnsafeRawPointer?\n var release: UnsafeRawPointer?\n var copyDescription: UnsafeRawPointer?\n}\ntypealias FSEventStreamCreateFlags = UInt32\ntypealias FSEventStreamEventId = UInt64\ntypealias FSEventStreamEventFlags = UInt32\n\ntypealias FSEventStreamCallback = @convention(c) (ConstFSEventStreamRef, UnsafeMutableRawPointer?, Int, UnsafeMutableRawPointer, UnsafePointer, UnsafePointer) -> Void\n\n#if true // avoid linker flags -undefined dynamic_lookup\nlet RTLD_DEFAULT = UnsafeMutableRawPointer(bitPattern: -2)\nlet FSEventStreamCreate = unsafeBitCast(dlsym(RTLD_DEFAULT, \"FSEventStreamCreate\"), to: (@convention(c) (_ allocator: CFAllocator?, _ callback: FSEventStreamCallback, _ context: UnsafeMutableRawPointer?, _ pathsToWatch: CFArray, _ sinceWhen: FSEventStreamEventId, _ latency: CFTimeInterval, _ flags: FSEventStreamCreateFlags) -> FSEventStreamRef?)?.self)\nlet FSEventStreamScheduleWithRunLoop = unsafeBitCast(dlsym(RTLD_DEFAULT, \"FSEventStreamScheduleWithRunLoop\"), to: (@convention(c) (_ streamRef: FSEventStreamRef, _ runLoop: CFRunLoop, _ runLoopMode: CFString) -> Void).self)\nlet FSEventStreamStart = unsafeBitCast(dlsym(RTLD_DEFAULT, \"FSEventStreamStart\"), to: (@convention(c) (_ streamRef: FSEventStreamRef) -> Bool).self)\nlet FSEventStreamGetLatestEventId = unsafeBitCast(dlsym(RTLD_DEFAULT, \"FSEventStreamGetLatestEventId\"), to: (@convention(c) (_ streamRef: FSEventStreamRef) -> FSEventStreamEventId).self)\nlet FSEventStreamStop = unsafeBitCast(dlsym(RTLD_DEFAULT, \"FSEventStreamStop\"), to: (@convention(c) (_ streamRef: FSEventStreamRef) -> Void).self)\n#else\n@_silgen_name(\"FSEventStreamCreate\")\nfunc FSEventStreamCreate(_ allocator: CFAllocator?, _ callback: FSEventStreamCallback, _ context: UnsafeMutablePointer?, _ pathsToWatch: CFArray, _ sinceWhen: FSEventStreamEventId, _ latency: CFTimeInterval, _ flags: FSEventStreamCreateFlags) -> FSEventStreamRef?\n@_silgen_name(\"FSEventStreamScheduleWithRunLoop\")\nfunc FSEventStreamScheduleWithRunLoop(_ streamRef: FSEventStreamRef, _ runLoop: CFRunLoop, _ runLoopMode: CFString)\n@_silgen_name(\"FSEventStreamStart\")\nfunc FSEventStreamStart(_ streamRef: FSEventStreamRef) -> Bool\n#endif\n\nlet kFSEventStreamEventIdSinceNow: UInt64 = 18446744073709551615\nlet kFSEventStreamCreateFlagUseCFTypes: FSEventStreamCreateFlags = 1\nlet kFSEventStreamCreateFlagFileEvents: FSEventStreamCreateFlags = 16\nlet kFSEventStreamEventFlagItemRenamed = 0x00000800\nlet kFSEventStreamEventFlagItemModified = 0x00001000\nfileprivate var watchers = [FSEventStreamRef: FileWatcher]()\n#endif\n#endif\n#endif\n"
},
{
"path": "Sources/HotReloading/InjectionClient.swift",
"content": "//\n// InjectionClient.swift\n// InjectionIII\n//\n// Created by John Holdsworth on 02/24/2021.\n// Copyright © 2021 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/InjectionClient.swift#91 $\n//\n// Client app side of HotReloading started by +load\n// method in HotReloadingGuts/ClientBoot.mm\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n#if SWIFT_PACKAGE\n#if canImport(InjectionScratch)\nimport InjectionScratch\n#endif\nimport Xprobe\nimport ProfileSwiftUI\n\npublic struct HotReloading {\n public static var stack: Void {\n injection_stack()\n }\n}\n#endif\n\n#if os(macOS)\nlet isVapor = true\n#else\nlet isVapor = dlsym(SwiftMeta.RTLD_DEFAULT, VAPOR_SYMBOL) != nil\n#endif\n\n@objc(InjectionClient)\npublic class InjectionClient: SimpleSocket, InjectionReader {\n\n let injectionQueue = isVapor ? DispatchQueue(label: \"InjectionQueue\") : .main\n var appVersion: String?\n\n open func log(_ msg: String) {\n print(APP_PREFIX+msg)\n }\n\n #if canImport(InjectionScratch)\n func next(scratch: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer {\n return scratch\n }\n #endif\n\n public override func runInBackground() {\n let builder = SwiftInjectionEval.sharedInstance()\n builder.tmpDir = NSTemporaryDirectory()\n\n write(INJECTION_SALT)\n write(INJECTION_KEY)\n\n let frameworksPath = Bundle.main.privateFrameworksPath!\n write(builder.tmpDir)\n write(builder.arch)\n let executable = Bundle.main.executablePath!\n write(executable)\n\n #if canImport(InjectionScratch)\n var isiOSAppOnMac = false\n if #available(iOS 14.0, *) {\n isiOSAppOnMac = ProcessInfo.processInfo.isiOSAppOnMac\n }\n if !isiOSAppOnMac, let scratch = loadScratchImage(nil, 0, self, nil) {\n log(\"⚠️ You are using device injection which is very much a work in progress. Expect the unexpected.\")\n writeCommand(InjectionResponse\n .scratchPointer.rawValue, with: nil)\n writePointer(next(scratch: scratch))\n }\n #endif\n\n builder.forceUnhide = { self.writeCommand(InjectionResponse\n .forceUnhide.rawValue, with: nil) }\n\n builder.tmpDir = readString() ?? \"/tmp\"\n\n builder.createUnhider(executable: executable,\n SwiftInjection.objcClassRefs,\n SwiftInjection.descriptorRefs)\n\n if getenv(INJECTION_UNHIDE) != nil {\n builder.legacyUnhide = true\n writeCommand(InjectionResponse.legacyUnhide.rawValue, with: \"1\")\n }\n\n var frameworkPaths = [String: String]()\n let isPlugin = builder.tmpDir == \"/tmp\"\n if (!isPlugin) {\n var frameworks = [String]()\n var sysFrameworks = [String]()\n\n for i in stride(from: _dyld_image_count()-1, through: 0, by: -1) {\n guard let imageName = _dyld_get_image_name(i),\n strstr(imageName, \".framework/\") != nil else {\n continue\n }\n let imagePath = String(cString: imageName)\n let frameworkName = URL(fileURLWithPath: imagePath).lastPathComponent\n frameworkPaths[frameworkName] = imagePath\n if imagePath.hasPrefix(frameworksPath) {\n frameworks.append(frameworkName)\n } else {\n sysFrameworks.append(frameworkName)\n }\n }\n\n writeCommand(InjectionResponse.frameworkList.rawValue, with:\n frameworks.joined(separator: FRAMEWORK_DELIMITER))\n write(sysFrameworks.joined(separator: FRAMEWORK_DELIMITER))\n write(SwiftInjection.packageNames()\n .joined(separator: FRAMEWORK_DELIMITER))\n }\n\n var codesignStatusPipe = [Int32](repeating: 0, count: 2)\n pipe(&codesignStatusPipe)\n let reader = SimpleSocket(socket: codesignStatusPipe[0])\n let writer = SimpleSocket(socket: codesignStatusPipe[1])\n\n builder.signer = { dylib -> Bool in\n self.writeCommand(InjectionResponse.getXcodeDev.rawValue,\n with: builder.xcodeDev)\n self.writeCommand(InjectionResponse.sign.rawValue, with: dylib)\n return reader.readString() == \"1\"\n }\n\n SwiftTrace.swizzleFactory = SwiftTrace.LifetimeTracker.self\n\n if let projectRoot = getenv(INJECTION_PROJECT_ROOT) {\n writeCommand(InjectionResponse.projectRoot.rawValue,\n with: String(cString: projectRoot))\n }\n if let derivedData = getenv(INJECTION_DERIVED_DATA) {\n writeCommand(InjectionResponse.derivedData.rawValue,\n with: String(cString: derivedData))\n }\n\n // Find client platform\n #if os(macOS) || targetEnvironment(macCatalyst)\n var platform = \"Mac\"\n #elseif os(tvOS)\n var platform = \"AppleTV\"\n #elseif os(visionOS)\n var platform = \"XR\"\n #elseif os(watchOS)\n var platform = \"Watch\"\n #else\n var platform = \"iPhone\"\n #endif\n\n #if targetEnvironment(simulator)\n platform += \"Simulator\"\n #else\n platform += \"OS\"\n #endif\n #if os(macOS)\n platform += \"X\"\n #endif\n writeCommand(InjectionResponse.platform.rawValue, with: platform)\n\n commandLoop:\n while true {\n let commandInt = readInt()\n guard let command = InjectionCommand(rawValue: commandInt) else {\n log(\"Invalid commandInt: \\(commandInt)\")\n break\n }\n switch command {\n case .EOF:\n log(\"EOF received from server..\")\n break commandLoop\n case .signed:\n writer.write(readString() ?? \"0\")\n case .traceFramework:\n let frameworkName = readString() ?? \"Misssing framework\"\n if let frameworkPath = frameworkPaths[frameworkName] {\n print(\"\\(APP_PREFIX)Tracing %s\\n\", frameworkPath)\n _ = SwiftTrace.interposeMethods(inBundlePath: frameworkPath,\n packageName: nil)\n SwiftTrace.trace(bundlePath:frameworkPath)\n } else {\n log(\"Tracing package \\(frameworkName)\")\n let mainBundlePath = Bundle.main.executablePath ?? \"Missing\"\n _ = SwiftTrace.interposeMethods(inBundlePath: mainBundlePath,\n packageName: frameworkName)\n }\n filteringChanged()\n default:\n process(command: command, builder: builder)\n }\n }\n\n builder.forceUnhide = {}\n log(\"\\(APP_NAME) disconnected.\")\n }\n\n func process(command: InjectionCommand, builder: SwiftEval) {\n switch command {\n case .vaccineSettingChanged:\n if let data = readString()?.data(using: .utf8),\n let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {\n builder.vaccineEnabled = json[UserDefaultsVaccineEnabled] as! Bool\n }\n case .connected:\n let projectFile = readString() ?? \"Missing project\"\n log(\"\\(APP_NAME) connected \\(projectFile)\")\n builder.projectFile = projectFile\n builder.derivedLogs = nil;\n case .watching:\n log(\"Watching files under the directory \\(readString() ?? \"Missing directory\")\")\n case .log:\n log(readString() ?? \"Missing log message\")\n case .ideProcPath:\n builder.lastIdeProcPath = readString() ?? \"\"\n case .invalid:\n log(\"⚠️ Server has rejected your connection. Are you running InjectionIII.app or start_daemon.sh from the right directory? ⚠️\")\n case .quietInclude:\n SwiftTrace.traceFilterInclude = readString()\n case .include:\n SwiftTrace.traceFilterInclude = readString()\n filteringChanged()\n case .exclude:\n SwiftTrace.traceFilterExclude = readString()\n filteringChanged()\n case .feedback:\n SwiftInjection.traceInjection = readString() == \"1\"\n case .lookup:\n SwiftTrace.typeLookup = readString() == \"1\"\n if SwiftTrace.swiftTracing {\n log(\"Discovery of target app's types switched \\(SwiftTrace.typeLookup ? \"on\" : \"off\")\");\n }\n case .trace:\n if SwiftTrace.traceMainBundleMethods() == 0 {\n log(\"⚠️ Tracing Swift methods can only work if you have -Xlinker -interposable to your project's Debug \\\"Other Linker Flags\\\"\")\n } else {\n log(\"Added trace to methods in main bundle\")\n }\n filteringChanged()\n case .untrace:\n SwiftTrace.removeAllTraces()\n case .traceUI:\n if SwiftTrace.traceMainBundleMethods() == 0 {\n log(\"⚠️ Tracing Swift methods can only work if you have -Xlinker -interposable to your project's Debug \\\"Other Linker Flags\\\"\")\n }\n SwiftTrace.traceMainBundle()\n log(\"Added trace to methods in main bundle\")\n filteringChanged()\n case .traceUIKit:\n DispatchQueue.main.sync {\n let OSView: AnyClass = (objc_getClass(\"UIView\") ??\n objc_getClass(\"NSView\")) as! AnyClass\n log(\"Adding trace to the framework containg \\(OSView), this will take a while...\")\n SwiftTrace.traceBundle(containing: OSView)\n log(\"Completed adding trace.\")\n }\n filteringChanged()\n case .traceSwiftUI:\n if let bundleOfAnyTextStorage = swiftUIBundlePath() {\n log(\"Adding trace to SwiftUI calls.\")\n _ = SwiftTrace.interposeMethods(inBundlePath: bundleOfAnyTextStorage, packageName:nil)\n filteringChanged()\n } else {\n log(\"Your app doesn't seem to use SwiftUI.\")\n }\n case .uninterpose:\n SwiftTrace.revertInterposes()\n SwiftTrace.removeAllTraces()\n log(\"Removed all traces (and injections).\")\n break;\n case .stats:\n let top = 200;\n print(\"\"\"\n\n \\(APP_PREFIX)Sorted top \\(top) elapsed time/invocations by method\n \\(APP_PREFIX)=================================================\n \"\"\")\n SwiftInjection.dumpStats(top:top)\n needsTracing()\n case .callOrder:\n print(\"\"\"\n\n \\(APP_PREFIX)Function names in the order they were first called:\n \\(APP_PREFIX)===================================================\n \"\"\")\n for signature in SwiftInjection.callOrder() {\n print(signature)\n }\n needsTracing()\n case .fileOrder:\n print(\"\"\"\n \\(APP_PREFIX)Source files in the order they were first referenced:\n \\(APP_PREFIX)=====================================================\n \\(APP_PREFIX)(Order the source files should be compiled in target)\n \"\"\")\n SwiftInjection.fileOrder()\n needsTracing()\n case .counts:\n print(\"\"\"\n \\(APP_PREFIX)Counts of live objects by class:\n \\(APP_PREFIX)================================\n \"\"\")\n SwiftInjection.objectCounts()\n needsTracing()\n case .fileReorder:\n writeCommand(InjectionResponse.callOrderList.rawValue,\n with:SwiftInjection.callOrder().joined(separator: CALLORDER_DELIMITER))\n needsTracing()\n case .copy:\n if let data = readData() {\n injectionQueue.async {\n var err: String?\n do {\n builder.injectionNumber += 1\n try data.write(to: URL(fileURLWithPath: \"\\(builder.tmpfile).dylib\"))\n try SwiftInjection.inject(tmpfile: builder.tmpfile)\n } catch {\n self.log(\"⚠️ Injection error: \\(error)\")\n err = \"\\(error)\"\n }\n let response: InjectionResponse = err != nil ? .error : .complete\n self.writeCommand(response.rawValue, with: err)\n }\n }\n case .pseudoUnlock:\n #if canImport(InjectionScratch)\n presentInjectionScratch(readString() ?? \"\")\n #endif\n case .objcClassRefs:\n if let array = readString()?\n .components(separatedBy: \",\") as NSArray?,\n let mutable = array.mutableCopy() as? NSMutableArray {\n SwiftInjection.objcClassRefs = mutable\n }\n case .descriptorRefs:\n if let array = readString()?\n .components(separatedBy: \",\") as NSArray?,\n let mutable = array.mutableCopy() as? NSMutableArray {\n SwiftInjection.descriptorRefs = mutable\n }\n case .setXcodeDev:\n if let xcodeDev = readString() {\n builder.xcodeDev = xcodeDev\n }\n case .appVersion:\n appVersion = readString()\n writeCommand(InjectionResponse.buildCache.rawValue,\n with: builder.buildCacheFile)\n case .profileUI:\n DispatchQueue.main.async {\n ProfileSwiftUI.profile()\n }\n default:\n processOnMainThread(command: command, builder: builder)\n }\n }\n\n func processOnMainThread(command: InjectionCommand, builder: SwiftEval) {\n guard let changed = self.readString() else {\n log(\"⚠️ Could not read changed filename?\")\n return\n }\n #if canImport(InjectionScratch)\n if command == .pseudoInject,\n let imagePointer = self.readPointer() {\n var percent = 0.0\n pushPseudoImage(changed, imagePointer)\n guard let imageEnd = loadScratchImage(imagePointer,\n self.readInt(), self, &percent) else { return }\n\n DispatchQueue.main.async {\n do {\n builder.injectionNumber += 1\n let tmpfile = String(cString: searchLastLoaded())\n let newClasses = try SwiftEval.instance.extractClasses(dl: UnsafeMutableRawPointer(bitPattern: ~0)!, tmpfile: tmpfile)\n try SwiftInjection.inject(tmpfile: tmpfile, newClasses: newClasses)\n } catch {\n NSLog(\"Pseudo: \\(error)\")\n }\n if percent > 75 {\n print(String(format: \"\\(APP_PREFIX)You have used %.1f%% of InjectionScratch space.\", percent))\n }\n self.writeCommand(InjectionResponse.scratchPointer.rawValue, with: nil)\n self.writePointer(self.next(scratch: imageEnd))\n }\n return\n }\n #endif\n injectionQueue.async {\n var err: String?\n switch command {\n case .load:\n do {\n builder.injectionNumber += 1\n try SwiftInjection.inject(tmpfile: changed)\n\n let countKey = \"__injectionsPerformed\", howOften = 100\n let count = UserDefaults.standard.integer(forKey: countKey)+1\n UserDefaults.standard.set(count, forKey: countKey)\n if count % howOften == 0 && getenv(\"INJECTION_SPONSOR\") == nil {\n SwiftInjection.log(\"\"\"\n ℹ️ Seems like you're using injection quite a bit. \\\n Have you considered sponsoring the project at \\\n https://github.com/johnno1962/\\(APP_NAME) or \\\n asking your boss if they should? (This message \\\n prints every \\(howOften) injections.)\n \"\"\")\n }\n } catch {\n err = error.localizedDescription\n }\n case .inject:\n if changed.hasSuffix(\"storyboard\") || changed.hasSuffix(\"xib\") {\n #if os(iOS) || os(tvOS)\n if !NSObject.injectUI(changed) {\n err = \"Interface injection failed\"\n }\n #else\n err = \"Interface injection not available on macOS.\"\n #endif\n } else {\n builder.forceUnhide = { builder.startUnhide() }\n SwiftInjection.inject(classNameOrFile: changed)\n }\n #if SWIFT_PACKAGE\n case .xprobe:\n Xprobe.connect(to: nil, retainObjects:true)\n Xprobe.search(\"\")\n case .eval:\n let parts = changed.components(separatedBy:\"^\")\n guard let pathID = Int(parts[0]) else { break }\n self.writeCommand(InjectionResponse.pause.rawValue, with:\"5\")\n if let object = (xprobePaths[pathID] as? XprobePath)?\n .object() as? NSObject, object.responds(to: Selector((\"swiftEvalWithCode:\"))),\n let code = (parts[3] as NSString).removingPercentEncoding,\n object.swiftEval(code: code) {\n } else {\n self.log(\"Xprobe: Eval only works on NSObject subclasses where the source file has the same name as the class and is in your project.\")\n }\n Xprobe.write(\"$('BUSY\\(pathID)').hidden = true; \")\n #endif\n default:\n self.log(\"⚠️ Unimplemented command: #\\(command.rawValue). \" +\n \"Are you running the most recent versions?\")\n }\n let response: InjectionResponse = err != nil ? .error : .complete\n self.writeCommand(response.rawValue, with: err)\n }\n }\n\n func needsTracing() {\n if !SwiftTrace.swiftTracing {\n log(\"⚠️ You need to have traced something to gather stats.\")\n }\n }\n\n func filteringChanged() {\n if SwiftTrace.swiftTracing {\n let exclude = SwiftTrace.traceFilterExclude\n if let include = SwiftTrace.traceFilterInclude {\n print(String(format: exclude != nil ?\n \"\\(APP_PREFIX)Filtering trace to include methods matching '%@' but not '%@'.\" :\n \"\\(APP_PREFIX)Filtering trace to include methods matching '%@'.\",\n include, exclude != nil ? exclude! : \"\"))\n } else {\n print(String(format: exclude != nil ?\n \"\\(APP_PREFIX)Filtering trace to exclude methods matching '%@'.\" :\n \"\\(APP_PREFIX)Not filtering trace (Menu Item: 'Set Filters')\",\n exclude != nil ? exclude! : \"\"))\n }\n }\n }\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/InjectionStats.swift",
"content": "//\n// InjectionStats.swift\n// \n// Created by John Holdsworth on 26/10/2022.\n// Copyright © 2022 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/InjectionStats.swift#4 $\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n\nextension SwiftInjection {\n\n @objc public class func dumpStats(top: Int) {\n let invocationCounts = SwiftTrace.invocationCounts()\n for (method, elapsed) in SwiftTrace.sortedElapsedTimes(onlyFirst: top) {\n print(\"\\(String(format: \"%.1f\", elapsed*1000.0))ms/\\(invocationCounts[method] ?? 0)\\t\\(method)\")\n }\n }\n\n @objc public class func callOrder() -> [String] {\n return SwiftTrace.callOrder().map { $0.signature }\n }\n\n @objc public class func fileOrder() {\n let builder = SwiftEval.sharedInstance()\n let signatures = callOrder()\n\n guard let projectRoot = builder.projectFile.flatMap({\n URL(fileURLWithPath: $0).deletingLastPathComponent().path+\"/\"\n }),\n let (_, logsDir) =\n try? builder.determineEnvironment(classNameOrFile: \"\") else {\n log(\"File ordering not available.\")\n return\n }\n\n let tmpfile = builder.tmpDir+\"/eval101\"\n var found = false\n\n SwiftEval.uniqueTypeNames(signatures: signatures) { typeName in\n if !typeName.contains(\"(\"), let (_, foundSourceFile) =\n try? builder.findCompileCommand(logsDir: logsDir,\n classNameOrFile: typeName, tmpfile: tmpfile) {\n print(foundSourceFile\n .replacingOccurrences(of: projectRoot, with: \"\"))\n found = true\n }\n }\n\n if !found {\n log(\"Do you have the right project selected?\")\n }\n }\n\n @objc public class func packageNames() -> [String] {\n var packages = Set()\n for suffix in SwiftTrace.traceableFunctionSuffixes {\n findSwiftSymbols(Bundle.main.executablePath!, suffix) {\n (_, symname: UnsafePointer, _, _) in\n if let sym = SwiftMeta.demangle(symbol: String(cString: symname)),\n !sym.hasPrefix(\"(extension in \"),\n let endPackage = sym.firstIndex(of: \".\") {\n packages.insert(sym[..<(endPackage+0)])\n }\n }\n }\n return Array(packages)\n }\n\n @objc public class func objectCounts() {\n for (className, count) in SwiftTrace.liveObjects\n .map({(_typeName(autoBitCast($0.key)), $0.value.count)})\n .sorted(by: {$0.0 < $1.0}) {\n print(\"\\(count)\\t\\(className)\")\n }\n }\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/ObjcInjection.swift",
"content": "//\n// ObjcInjection.swift\n//\n// Created by John Holdsworth on 17/03/2022.\n// Copyright © 2022 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/ObjcInjection.swift#23 $\n//\n// Code specific to \"classic\" Objective-C method swizzling.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n\nextension SwiftInjection.MachImage {\n func symbols(withPrefix: UnsafePointer,\n apply: @escaping (UnsafeRawPointer, UnsafePointer,\n UnsafePointer) -> Void) {\n let prefixLen = strlen(withPrefix)\n fast_dlscan(self, .any, {\n return strncmp($0, withPrefix, prefixLen) == 0}) {\n (address, symname, _, _) in\n apply(address, symname, symname + prefixLen - 1)\n }\n }\n}\n\nextension SwiftInjection {\n\n public typealias MachImage = UnsafePointer\n\n /// New method of swizzling based on symbol names\n /// - Parameters:\n /// - oldClass: original class to be swizzled\n /// - tmpfile: no longer used\n /// - Returns: # methods swizzled\n public class func injection(swizzle oldClass: AnyClass, tmpfile: String) -> Int {\n var methodCount: UInt32 = 0, swizzled = 0\n if let methods = class_copyMethodList(oldClass, &methodCount) {\n for i in 0 ..< Int(methodCount) {\n swizzled += swizzle(oldClass: oldClass,\n selector: method_getName(methods[i]), tmpfile)\n }\n free(methods)\n }\n return swizzled\n }\n\n /// Swizzle the newly loaded implementation of a selector onto oldClass\n /// - Parameters:\n /// - oldClass: orignal class to be swizzled\n /// - selector: method selector to be swizzled\n /// - tmpfile: no longer used\n /// - Returns: # methods swizzled\n public class func swizzle(oldClass: AnyClass, selector: Selector,\n _ tmpfile: String) -> Int {\n var swizzled = 0\n if let method = class_getInstanceMethod(oldClass, selector),\n let existing = unsafeBitCast(method_getImplementation(method),\n to: UnsafeMutableRawPointer?.self),\n let selsym = originalSym(for: existing) {\n if let replacement = fast_dlsym(lastLoadedImage(), selsym) {\n traceAndReplace(existing, replacement: replacement,\n objcMethod: method, objcClass: oldClass) {\n (replacement: IMP) -> String? in\n if class_replaceMethod(oldClass, selector, replacement,\n method_getTypeEncoding(method)) != nil {\n swizzled += 1\n return \"Swizzled\"\n }\n return nil\n }\n } else {\n detail(\"⚠️ Swizzle failed \"+describeImageSymbol(selsym))\n }\n }\n return swizzled\n }\n\n /// Fallback to make sure at least the @objc func injected() and viewDidLoad() methods are swizzled\n public class func swizzleBasics(oldClass: AnyClass, tmpfile: String) -> Int {\n var swizzled = swizzle(oldClass: oldClass, selector: injectedSEL, tmpfile)\n #if os(iOS) || os(tvOS)\n swizzled += swizzle(oldClass: oldClass, selector: viewDidLoadSEL, tmpfile)\n #endif\n return swizzled\n }\n\n /// Original Objective-C swizzling\n /// - Parameters:\n /// - oldClass: Original class to be swizzle\n /// - newClass: Newly loaded class\n /// - Returns: # of methods swizzled\n public class func injection(swizzle oldClass: AnyClass?,\n from newClass: AnyClass?) -> Int {\n var methodCount: UInt32 = 0, swizzled = 0\n if let methods = class_copyMethodList(newClass, &methodCount) {\n for i in 0 ..< Int(methodCount) {\n let selector = method_getName(methods[i])\n let replacement = method_getImplementation(methods[i])\n guard let method = class_getInstanceMethod(oldClass, selector) ??\n class_getInstanceMethod(newClass, selector),\n let existing = i < 0 ? nil : method_getImplementation(method) else {\n continue\n }\n traceAndReplace(existing, replacement: autoBitCast(replacement),\n objcMethod: methods[i], objcClass: newClass) {\n (replacement: IMP) -> String? in\n if class_replaceMethod(oldClass, selector, replacement,\n method_getTypeEncoding(methods[i])) != replacement {\n swizzled += 1\n return \"Swizzled\"\n }\n return nil\n }\n }\n free(methods)\n }\n return swizzled\n }\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/ReducerInjection.swift",
"content": "//\n// ReducerInjection.swift\n//\n// Created by John Holdsworth on 09/06/2022.\n// Copyright © 2022 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/ReducerInjection.swift#12 $\n//\n// Support for injecting \"The Composble Architecture\" Reducers using TCA fork:\n// https://github.com/thebrowsercompany/swift-composable-architecture/tree/develop\n// Top level Reducer var initialisations are wrapped in ARCInjectable() call.\n// Reducers are now deprecated in favour of using the new \"ReducerProtocol\".\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n\nextension NSObject {\n\n @objc\n public func registerInjectableTCAReducer(_ symbol: String) {\n SwiftInjection.injectableReducerSymbols.insert(symbol)\n }\n}\n\nextension SwiftInjection {\n\n static var injectableReducerSymbols = Set()\n \n static var checkReducerInitializers: Void = {\n var expectedInjectableReducerSymbols = Set()\n\n findHiddenSwiftSymbols(searchBundleImages(), \"Reducer_WZ\", .any) {\n _, symname, _, _ in\n expectedInjectableReducerSymbols.insert(String(cString: symname))\n }\n\n for symname in expectedInjectableReducerSymbols\n .subtracting(injectableReducerSymbols) {\n let sym = SwiftMeta.demangle(symbol: symname) ?? symname\n let variable = sym.components(separatedBy: \" \").last ?? sym\n log(\"⚠️ \\(variable) is not injectable (or unused), wrap it with ARCInjectable\")\n }\n }()\n\n /// Support for re-initialising \"The Composable Architecture\", \"Reducer\"\n /// variables declared at the top level. Requires custom version of TCA:\n /// https://github.com/thebrowsercompany/swift-composable-architecture/tree/develop\n public class func reinitializeInjectedReducers(_ tmpfile: String,\n reinitialized: UnsafeMutablePointer<[SymbolName]>) {\n _ = checkReducerInitializers\n findHiddenSwiftSymbols(searchLastLoaded(), \"_WZ\", .local) {\n accessor, symname, _, _ in\n if injectableReducerSymbols.contains(String(cString: symname)) {\n typealias OneTimeInitialiser = @convention(c) () -> Void\n let reinitialise: OneTimeInitialiser = autoBitCast(accessor)\n reinitialise()\n reinitialized.pointee.append(symname)\n }\n }\n }\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/StandaloneInjection.swift",
"content": "//\n// StandaloneInjection.swift\n//\n// Created by John Holdsworth on 15/03/2022.\n// Copyright © 2022 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/StandaloneInjection.swift#77 $\n//\n// Standalone version of the HotReloading version of the InjectionIII project\n// https://github.com/johnno1962/InjectionIII. This file allows you to\n// add HotReloading to a project without having to add a \"Run Script\"\n// build phase to run the daemon process.\n//\n// The most recent change was for the InjectionIII.app injection bundles\n// to fall back to this implementation if the user is not running the app.\n// This was made possible by using the FileWatcher to find the build log\n// directory in DerivedData of the most recently built project.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\n#if targetEnvironment(simulator) && !APP_SANDBOXED || os(macOS)\n#if canImport(UIKit)\nimport UIKit\n#endif\n\n@objc(StandaloneInjection)\nclass StandaloneInjection: InjectionClient {\n\n static var singleton: StandaloneInjection?\n var watchers = [FileWatcher]()\n\n override func runInBackground() {\n let builder = SwiftInjectionEval.sharedInstance()\n builder.tmpDir = NSTemporaryDirectory()\n #if SWIFT_PACKAGE\n let swiftTracePath = String(cString: swiftTrace_path())\n // convert SwiftTrace path into path to logs.\n builder.derivedLogs = swiftTracePath.replacingOccurrences(of:\n #\"SourcePackages/checkouts/SwiftTrace/SwiftTraceGutsD?/SwiftTrace.mm$\"#,\n with: \"Logs/Build\", options: .regularExpression)\n if builder.derivedLogs == swiftTracePath {\n log(\"⚠️ HotReloading could find log directory from: \\(swiftTracePath)\")\n builder.derivedLogs = nil // let FileWatcher find logs\n }\n #endif\n signal(SIGPIPE, { _ in print(APP_PREFIX+\"⚠️ SIGPIPE\") })\n builder.signer = { _ in\n #if os(tvOS)\n let dylib = builder.tmpfile+\".dylib\"\n let codesign = \"\"\"\n (export CODESIGN_ALLOCATE=\\\"\\(builder.xcodeDev\n )/Toolchains/XcodeDefault.xctoolchain/usr/bin/codesign_allocate\\\"; \\\n if /usr/bin/file \\\"\\(dylib)\\\" | /usr/bin/grep ' shared library ' >/dev/null; \\\n then /usr/bin/codesign --force -s - \\\"\\(dylib)\\\";\\\n else exit 1; fi) >>/tmp/hot_reloading.log 2>&1\n \"\"\"\n return builder.shell(command: codesign)\n #else\n return true\n #endif\n }\n builder.debug = { (what: Any...) in\n //print(\"\\(APP_PREFIX)***** %@\", what.map {\"\\($0)\"}.joined(separator: \" \"))\n }\n builder.forceUnhide = { builder.startUnhide() }\n builder.bazelLight = true\n\n let home = NSHomeDirectory()\n .replacingOccurrences(of: #\"(/Users/[^/]+).*\"#, with: \"$1\",\n options: .regularExpression)\n setenv(\"USER_HOME\", home, 1)\n\n var dirs = [home]\n let library = home+\"/Library\"\n if let extra = getenv(INJECTION_DIRECTORIES) {\n dirs = String(cString: extra).components(separatedBy: \",\")\n .map { $0[#\"^~\"#, substitute: home] } // expand ~ in paths\n if builder.derivedLogs == nil && dirs.allSatisfy({\n $0 != home && !$0.hasPrefix(library) }) {\n log(\"⚠️ INJECTION_DIRECTORIES should contain ~/Library\")\n dirs.append(library)\n }\n }\n\n var lastInjected = [String: TimeInterval]()\n\n if getenv(INJECTION_REPLAY) != nil {\n injectionQueue.sync {\n _ = SwiftInjection.replayInjections()\n }\n }\n\n let isVapor = injectionQueue != .main\n let holdOff = 1.0, minInterval = 0.33 // seconds\n let firstInjected = Date.timeIntervalSinceReferenceDate + holdOff\n watchers.append(FileWatcher(roots: dirs,\n callback: { filesChanged, idePath in\n #if canImport(UIKit) && !os(watchOS)\n if UIApplication.shared.applicationState != .active { return }\n #endif\n builder.lastIdeProcPath = idePath\n if builder.derivedLogs == nil {\n if let lastBuilt = FileWatcher.derivedLog {\n builder.derivedLogs = URL(fileURLWithPath: lastBuilt)\n .deletingLastPathComponent().path\n self.log(\"Using logs: \\(lastBuilt).\")\n } else {\n self.log(\"⚠️ Build log for project not found. \" +\n \"Please edit a file and build it.\")\n return\n }\n }\n\n for changed in filesChanged {\n guard let changed = changed as? String,\n !changed.hasPrefix(library) && !changed.contains(\"/.\"),\n Date.timeIntervalSinceReferenceDate -\n lastInjected[changed, default: firstInjected] >\n minInterval else {\n continue\n }\n if changed.hasSuffix(\".storyboard\") ||\n changed.hasSuffix(\".xib\") {\n #if os(iOS) || os(tvOS)\n if !NSObject.injectUI(changed) {\n self.log(\"⚠️ Interface injection failed\")\n }\n #endif\n } else {\n SwiftInjection.inject(classNameOrFile: changed)\n }\n lastInjected[changed] = Date.timeIntervalSinceReferenceDate\n }\n }, runLoop: isVapor ? CFRunLoopGetCurrent() : nil))\n\n log(\"Standalone \\(APP_NAME) available for sources under \\(dirs)\")\n if #available(iOS 14.0, tvOS 14.0, *) {\n } else {\n log(\"ℹ️ HotReloading not available on Apple Silicon before iOS 14.0\")\n }\n if let executable = Bundle.main.executablePath {\n builder.createUnhider(executable: executable,\n SwiftInjection.objcClassRefs,\n SwiftInjection.descriptorRefs)\n }\n\n Self.singleton = self\n if isVapor {\n CFRunLoopRun()\n }\n }\n\n var swiftTracing: String?\n\n func maybeTrace() {\n if let pattern = getenv(INJECTION_TRACE)\n .flatMap({String(cString: $0)}), pattern != swiftTracing {\n SwiftTrace.typeLookup = getenv(INJECTION_LOOKUP) != nil\n SwiftInjection.traceInjection = true\n if pattern != \"\" {\n // This alone will not work for non-final class methods.\n _ = SwiftTrace.interpose(aBundle: searchBundleImages(),\n methodName: pattern)\n }\n swiftTracing = pattern\n }\n }\n}\n#endif\n#endif\n"
},
{
"path": "Sources/HotReloading/SwiftEval.swift",
"content": "//\n// SwiftEval.swift\n// InjectionBundle\n//\n// Created by John Holdsworth on 02/11/2017.\n// Copyright © 2017 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/SwiftEval.swift#302 $\n//\n// Basic implementation of a Swift \"eval()\" including the\n// mechanics of recompiling a class and loading the new\n// version used in the associated injection version.\n// Used as the basis of a new version of Injection.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\n#if arch(x86_64) || arch(i386) || arch(arm64) // simulator/macOS only\nimport Foundation\n#if SWIFT_PACKAGE\n@_exported import HotReloadingGuts\n#elseif !INJECTION_III_APP\nprivate let APP_PREFIX = \"💉 \",\n INJECTION_DERIVED_DATA = \"INJECTION_DERIVED_DATA\"\n#endif\n\n#if !INJECTION_III_APP\n#if canImport(SwiftTraceD)\nimport SwiftTraceD\n#endif\n\n@objc protocol SwiftEvalImpl {\n @objc optional func evalImpl(_ptr: UnsafeMutableRawPointer)\n}\n\nextension NSObject {\n\n private static var lastEvalByClass = [String: String]()\n\n @objc public func swiftEval(code: String) -> Bool {\n if let closure = swiftEval(\"{\\n\\(code)\\n}\", type: (() -> ())?.self) {\n closure()\n return true\n }\n return false\n }\n\n /// eval() for String value\n @objc public func swiftEvalString(contents: String) -> String {\n return swiftEval(\"\"\"\n \"\\(contents)\"\n \"\"\", type: String.self)\n }\n\n /// eval() for value of any type\n public func swiftEval(_ expression: String, type: T.Type) -> T {\n let oldClass: AnyClass = object_getClass(self)!\n let className = \"\\(oldClass)\"\n let extra = \"\"\"\n\n extension \\(className) {\n\n @objc func evalImpl(_ptr: UnsafeMutableRawPointer) {\n func xprint(_ str: T) {\n if let xprobe = NSClassFromString(\"Xprobe\") {\n #if swift(>=4.0)\n _ = (xprobe as AnyObject).perform(Selector((\"xlog:\")), with: \"\\\\(str)\")\n #elseif swift(>=3.0)\n Thread.detachNewThreadSelector(Selector((\"xlog:\")), toTarget:xprobe, with:\"\\\\(str)\" as NSString)\n #else\n NSThread.detachNewThreadSelector(Selector(\"xlog:\"), toTarget:xprobe, withObject:\"\\\\(str)\" as NSString)\n #endif\n }\n }\n\n #if swift(>=3.0)\n struct XprobeOutputStream: TextOutputStream {\n var out = \"\"\n mutating func write(_ string: String) {\n out += string\n }\n }\n\n func xdump(_ arg: T) {\n var stream = XprobeOutputStream()\n dump(arg, to: &stream)\n xprint(stream.out)\n }\n #endif\n\n let _ptr = _ptr.assumingMemoryBound(to: (\\(type)).self)\n _ptr.pointee = \\(expression)\n }\n }\n\n \"\"\"\n\n // update evalImpl to implement expression\n\n if NSObject.lastEvalByClass[className] != expression {\n do {\n let tmpfile = try SwiftEval.instance.rebuildClass(oldClass: oldClass,\n classNameOrFile: className, extra: extra)\n if let newClass = try SwiftEval.instance\n .loadAndInject(tmpfile: tmpfile, oldClass: oldClass).first {\n if NSStringFromClass(newClass) != NSStringFromClass(oldClass) {\n NSLog(\"Class names different. Have the right class been loaded?\")\n }\n\n // swizzle new version of evalImpl onto class\n\n let selector = #selector(SwiftEvalImpl.evalImpl(_ptr:))\n if let newMethod = class_getInstanceMethod(newClass, selector) {\n class_replaceMethod(oldClass, selector,\n method_getImplementation(newMethod),\n method_getTypeEncoding(newMethod))\n NSObject.lastEvalByClass[className] = expression\n }\n }\n }\n catch {\n }\n }\n\n // call patched evalImpl to realise expression\n\n let ptr = UnsafeMutablePointer.allocate(capacity: 1)\n bzero(ptr, MemoryLayout.size)\n if NSObject.lastEvalByClass[className] == expression {\n unsafeBitCast(self, to: SwiftEvalImpl.self).evalImpl?(_ptr: ptr)\n }\n let out = ptr.pointee\n ptr.deallocate()\n return out\n }\n}\n#endif\n\nextension StringProtocol {\n subscript(range: NSRange) -> String? {\n return Range(range, in: String(self)).flatMap { String(self[$0]) }\n }\n func escaping(_ chars: String = \"' {}()&*\",\n with template: String = \"\\\\$0\") -> String {\n return self.replacingOccurrences(of: \"[\\(chars)]\",\n with: template.replacingOccurrences(of: #\"\\\"#, with: \"\\\\\\\\\"),\n options: [.regularExpression])\n }\n func unescape() -> String {\n return replacingOccurrences(of: #\"\\\\(.)\"#, with: \"$1\",\n options: .regularExpression)\n }\n}\n\n@objc(SwiftEval)\npublic class SwiftEval: NSObject {\n\n static var instance = SwiftEval()\n static let bundleLink = \"/tmp/injection.link\"\n\n @objc public class func sharedInstance() -> SwiftEval {\n return instance\n }\n\n @objc public var signer: ((_: String) -> Bool)?\n @objc public var vaccineEnabled: Bool = false\n\n // client specific info\n @objc public var frameworks = Bundle.main.privateFrameworksPath\n ?? Bundle.main.bundlePath + \"/Frameworks\"\n #if arch(arm64)\n @objc public var arch = \"arm64\"\n #elseif arch(x86_64)\n @objc public var arch = \"x86_64\"\n #else\n @objc public var arch = \"i386\"\n #endif\n\n var forceUnhide = {}\n var legacyUnhide = false\n var objectUnhider: ((String) -> Void)?\n var linkerOptions = \"\"\n\n let bazelWorkspace = \"IGNORE_WORKSPACE\"\n let skipBazelLinking = \"--skip_linking\"\n var bazelLight = getenv(\"INJECTION_BAZEL\") != nil ||\n UserDefaults.standard.bool(forKey: \"bazelLight\")\n var moduleLibraries = Set()\n\n /// Additional logging to /tmp/hot\\_reloading.log for \"HotReloading\" version of injection.\n var debug = { (what: Any...) in\n if getenv(\"INJECTION_DEBUG\") != nil || getenv(\"DERIVED_LOGS\") != nil {\n NSLog(\"\\(APP_PREFIX)***** %@\", what.map {\"\\($0)\"}.joined(separator: \" \"))\n }\n }\n\n // Xcode related info\n @objc public var xcodeDev = \"/Applications/Xcode.app/Contents/Developer\" {\n willSet(newValue) {\n if newValue != xcodeDev {\n print(APP_PREFIX+\"Selecting Xcode \\(newValue)\")\n }\n }\n }\n\n @objc public var projectFile: String?\n @objc public var derivedLogs: String?\n @objc public var tmpDir = \"/tmp\" {\n didSet {\n// SwiftEval.buildCacheFile = \"\\(tmpDir)/eval_builds.plist\"\n }\n }\n @objc public var injectionNumber = 100\n @objc public var lastIdeProcPath = \"\"\n\n var tmpfile: String { URL(fileURLWithPath: tmpDir)\n .appendingPathComponent(\"eval\\(injectionNumber)\").path }\n var logfile: String { \"\\(tmpfile).log\" }\n var cmdfile: String { URL(fileURLWithPath: tmpDir)\n .appendingPathComponent(\"command.sh\").path\n }\n\n /// Error handler\n @objc public var evalError = {\n (_ message: String) -> Error in\n print(APP_PREFIX+(message.hasPrefix(\"Compiling\") ?\"\":\"⚠️ \")+message)\n return NSError(domain: \"SwiftEval\", code: -1,\n userInfo: [NSLocalizedDescriptionKey: message])\n }\n\n func scriptError(_ what: String) -> Error {\n var log = (try? String(contentsOfFile: logfile)) ??\n \"Could not read log file '\\(logfile)'\"\n if log.contains(\".h' file not found\") {\n log += \"\\(APP_PREFIX)⚠️ Adjust the \\\"Header Search Paths\\\" in your project's Build Settings\"\n }\n return evalError(\"\"\"\n \\(what) failed (see: \\(cmdfile))\n \\(log)\n \"\"\")\n }\n\n var compileByClass = [String: (String, String)]()\n\n static let simulatorCacheFile = \"/tmp/iOS_Simulator_builds.plist\"\n\n #if os(macOS) || targetEnvironment(macCatalyst)\n var buildCacheFile = \"/tmp/macOS_builds.plist\"\n #elseif os(tvOS)\n var buildCacheFile = \"/tmp/tvOS_builds.plist\"\n #elseif os(visionOS)\n var buildCacheFile = \"/tmp/xrOS_builds.plist\"\n #elseif targetEnvironment(simulator)\n var buildCacheFile = SwiftEval.simulatorCacheFile\n #else\n var buildCacheFile = \"/tmp/iOS_builds.plist\"\n #endif\n lazy var longTermCache =\n NSMutableDictionary(contentsOfFile: buildCacheFile) ?? NSMutableDictionary()\n\n public func determineEnvironment(classNameOrFile: String) throws -> (URL, URL) {\n // Largely obsolete section used find Xcode paths from source file being injected.\n\n let sourceURL = URL(fileURLWithPath:\n classNameOrFile.hasPrefix(\"/\") ? classNameOrFile : #file)\n debug(\"Project file:\", projectFile ?? \"nil\")\n guard let derivedData = getenv(INJECTION_DERIVED_DATA).flatMap({\n let url = URL(fileURLWithPath: String(cString: $0))\n guard FileManager.default.fileExists(atPath: url.path) else {\n _ = evalError(\"Invalid path in \\(INJECTION_DERIVED_DATA): \"+url.path)\n return nil }\n return url }) ??\n findDerivedData(url: URL(fileURLWithPath: NSHomeDirectory())) ??\n (projectFile == nil ? findDerivedData(url: sourceURL) :\n findDerivedData(url: URL(fileURLWithPath: projectFile!))) else {\n throw evalError(\"\"\"\n Could not locate derived data. Is the project under your \\\n home directory? If you are using a custom derived data path, \\\n add it as an environment variable \\(INJECTION_DERIVED_DATA) \\\n in your scheme.\n \"\"\")\n }\n debug(\"DerivedData:\", derivedData.path)\n guard let (projectFile, logsDir) =\n derivedLogs.flatMap({\n (findProject(for: sourceURL, derivedData:derivedData)?\n .projectFile ?? URL(fileURLWithPath: \"/tmp/x.xcodeproj\"),\n URL(fileURLWithPath: $0)) }) ??\n projectFile\n .flatMap({ logsDir(project: URL(fileURLWithPath: $0), derivedData: derivedData) })\n .flatMap({ (URL(fileURLWithPath: projectFile!), $0) }) ??\n findProject(for: sourceURL, derivedData: derivedData) else {\n throw evalError(\"\"\"\n Could not locate containing project or it's logs.\n For a macOS app you need to turn off the App Sandbox.\n Are using a custom DerivedData path? This is not supported.\n \"\"\")\n }\n\n if false == (try? String(contentsOf: projectFile\n .appendingPathComponent(\"project.pbxproj\")))?.contains(\"-interposable\") {\n print(APP_PREFIX+\"\"\"\n ⚠️ Project file \\(projectFile.path) does not contain the -interposable \\\n linker flag. In order to be able to inject methods of structs and final \\\n classes, please add \\\"Other Linker Flags\\\" -Xlinker -interposable for Debug builds only.\n \"\"\")\n }\n\n return (projectFile, logsDir)\n }\n\n public func actualCase(path: String) -> String? {\n let fm = FileManager.default\n if fm.fileExists(atPath: path) {\n return path\n }\n var out = \"\"\n for component in path.split(separator: \"/\") {\n var real: String?\n if fm.fileExists(atPath: out+\"/\"+component) {\n real = String(component)\n } else {\n guard let contents = try? fm.contentsOfDirectory(atPath: \"/\"+out) else {\n return nil\n }\n real = contents.first { $0.lowercased() == component.lowercased() }\n }\n\n guard let found = real else {\n return nil\n }\n out += \"/\" + found\n }\n return out\n }\n\n let detectFilepaths = try! NSRegularExpression(pattern: #\"(/(?:[^\\ ]*\\\\.)*[^\\ ]*) \"#)\n\n @objc public func rebuildClass(oldClass: AnyClass?,\n classNameOrFile: String, extra: String?) throws -> String {\n let (projectFile, logsDir) = try\n determineEnvironment(classNameOrFile: classNameOrFile)\n let projectRoot = projectFile.deletingLastPathComponent().path\n// if self.projectFile == nil { self.projectFile = projectFile.path }\n\n // locate compile command for class\n\n injectionNumber += 1\n\n if projectFile.lastPathComponent == bazelWorkspace,\n let dylib = try bazelLight(projectRoot: projectRoot,\n recompile: classNameOrFile) {\n return dylib\n }\n\n guard var (compileCommand, sourceFile) = try\n compileByClass[classNameOrFile] ??\n (longTermCache[classNameOrFile] as? String)\n .flatMap({ ($0, classNameOrFile) }) ??\n findCompileCommand(logsDir: logsDir,\n classNameOrFile: classNameOrFile, tmpfile: tmpfile) else {\n throw evalError(\"\"\"\n Could not locate compile command for \"\\(classNameOrFile)\" in \\\n \\(logsDir.path)/.\\nThis could be due to one of the following:\n 1. Injection does not work with Whole Module Optimization.\n 2. There are restrictions on characters allowed in paths.\n 3. File paths in the simulator are case sensitive.\n 4. The modified source file is not in the current project.\n 5. The source file is an XCTest that has not been run yet.\n 6. Xcode has removed the build logs. Edit a file and re-run \\\n or try a build clean then rebuild to make logs available or \\\n consult: \"\\(cmdfile)\".\n 7. If you're using Xcode 16.3+, Swift compilation details are no \\\n longer logged by default. See the note in the project README. \\\n You'll need to add a EMIT_FRONTEND_COMMAND_LINES custom \\\n build setting to your project to continue using InjectionIII.\n Whatever the problem, if you see this error it may be worth \\\n trying the start-over implementation https://github.com/johnno1962/InjectionNext.\n \"\"\")\n }\n sourceFile += \"\" // remove warning\n\n #if targetEnvironment(simulator)\n // Normalise paths in compile command with the actual casing\n // of files as the simulator has a case-sensitive file system.\n for filepath in detectFilepaths.matches(in: compileCommand, options: [],\n range: NSMakeRange(0, compileCommand.utf16.count))\n .compactMap({ compileCommand[$0.range(at: 1)] }) {\n let unescaped = filepath.unescape()\n if let normalised = actualCase(path: unescaped) {\n let escaped = normalised.escaping(\"' ${}()&*~\")\n if filepath != escaped {\n print(\"\"\"\n \\(APP_PREFIX)Mapped: \\(filepath)\n \\(APP_PREFIX)... to: \\(escaped)\n \"\"\")\n compileCommand = compileCommand\n .replacingOccurrences(of: filepath, with: escaped,\n options: .caseInsensitive)\n }\n }\n }\n #endif\n\n // load and patch class source if there is an extension to add\n\n let filemgr = FileManager.default, backup = sourceFile + \".tmp\"\n if extra != nil {\n guard var classSource = try? String(contentsOfFile: sourceFile) else {\n throw evalError(\"Could not load source file \\(sourceFile)\")\n }\n\n let changesTag = \"// extension added to implement eval\"\n classSource = classSource.components(separatedBy: \"\\n\\(changesTag)\\n\")[0] + \"\"\"\n\n \\(changesTag)\n \\(extra!)\n\n \"\"\"\n\n debug(classSource)\n\n // backup original and compile patched class source\n\n if !filemgr.fileExists(atPath: backup) {\n try! filemgr.moveItem(atPath: sourceFile, toPath: backup)\n }\n try! classSource.write(toFile: sourceFile, atomically: true, encoding: .utf8)\n }\n\n defer {\n if extra != nil {\n try! filemgr.removeItem(atPath: sourceFile)\n try! filemgr.moveItem(atPath: backup, toPath: sourceFile)\n }\n }\n\n // Extract object path (overidden in UnhidingEval.swift for Xcode 13)\n let objectFile = xcode13Fix(sourceFile: sourceFile,\n compileCommand: &compileCommand)\n\n _ = evalError(\"Compiling \\(sourceFile)\")\n\n let isBazelCompile = compileCommand.contains(skipBazelLinking)\n if isBazelCompile, arch == \"x86_64\", !compileCommand.contains(arch) {\n compileCommand = compileCommand\n .replacingOccurrences(of: #\"(--cpu=ios_)\\w+\"#,\n with: \"$1\\(arch)\", options: .regularExpression)\n }\n\n if !sourceFile.hasSuffix(\".swift\") {\n compileCommand += \" -Xclang -fno-validate-pch\"\n }\n\n debug(\"Final command:\", compileCommand, \"-->\", objectFile)\n guard shell(command: \"\"\"\n (cd \"\\(projectRoot.escaping(\"$\"))\" && \\\n \\(compileCommand) >\\\"\\(logfile)\\\" 2>&1)\n \"\"\") || isBazelCompile else {\n if longTermCache[classNameOrFile] != nil {\n updateLongTermCache(remove: classNameOrFile)\n do {\n return try rebuildClass(oldClass: oldClass,\n classNameOrFile: classNameOrFile, extra: extra)\n } catch {\n #if true || !os(macOS)\n _ = evalError(\"Recompilation failing, are you renaming/adding \" +\n \"files? Build your project to generate a new Xcode build \" +\n \"log and try injecting again or relauch your app.\")\n throw error\n #else\n // Retry again with new build log in case of added/renamed files...\n _ = evalError(\"Compilation failed, rebuilding \\(projectFile.path)\")\n _ = shell(command: \"\"\"\n /usr/bin/osascript -e 'tell application \"Xcode\"\n set targetProject to active workspace document\n if (build targetProject) is equal to \"Build succeeded\" then\n end if\n end tell'\n \"\"\")\n return try rebuildClass(oldClass: oldClass,\n classNameOrFile: classNameOrFile, extra: extra)\n #endif\n }\n }\n throw scriptError(\"Re-compilation\")\n }\n\n compileByClass[classNameOrFile] = (compileCommand, sourceFile)\n if longTermCache[classNameOrFile] as? String != compileCommand &&\n classNameOrFile.hasPrefix(\"/\") {//&& scanTime > slowLogScan {\n longTermCache[classNameOrFile] = compileCommand\n updateLongTermCache()\n }\n\n if isBazelCompile {\n let projectRoot = objectFile // returned by xcode13Fix()\n return try bazelLink(in: projectRoot, since: sourceFile,\n compileCommand: compileCommand)\n }\n\n // link resulting object file to create dynamic library\n _ = objectUnhider?(objectFile)\n\n var speclib = \"\"\n if sourceFile.contains(\"Spec.\") && (try? String(\n contentsOfFile: classNameOrFile))?.contains(\"Quick\") == true {\n speclib = logsDir.path+\"/../../Build/Products/\"+Self.quickFiles\n }\n\n try link(dylib: \"\\(tmpfile).dylib\", compileCommand: compileCommand,\n contents: \"\\\"\\(objectFile)\\\" \\(speclib)\")\n return tmpfile\n }\n\n func updateLongTermCache(remove: String? = nil) {\n if let source = remove {\n compileByClass.removeValue(forKey: source)\n longTermCache.removeObject(forKey: source)\n// longTermCache.removeAllObjects()\n// compileByClass.removeAll()\n }\n longTermCache.write(toFile: buildCacheFile,\n atomically: false)\n }\n\n // Implementations provided in UnhidingEval.swift\n func bazelLight(projectRoot: String, recompile sourceFile: String) throws -> String? {\n throw evalError(\"No bazel support\")\n }\n\n func bazelLink(in projectRoot: String, since sourceFile: String,\n compileCommand: String) throws -> String {\n throw evalError(\"No bazel support\")\n }\n\n static let quickFiles = getenv(\"INJECTION_QUICK_FILES\").flatMap {\n String(cString: $0) } ?? \"Debug-*/{Quick*,Nimble,Cwl*}.o\"\n static let quickDylib = \"_spec.dylib\"\n static let dylibDelim = \"===\"\n static let parsePlatform = try! NSRegularExpression(pattern:\n #\"-(?:isysroot|sdk)(?: |\"\\n\")((\\#(fileNameRegex)/Contents/Developer)/Platforms/(\\w+)\\.platform\\#(fileNameRegex)\\#\\.sdk)\"#)\n\n func link(dylib: String, compileCommand: String, contents: String,\n cd: String = \"\") throws {\n var platform: String\n switch buildCacheFile {\n case Self.simulatorCacheFile: platform = \"iPhoneSimulator\"\n case \"/tmp/xrOS_builds.plist\": platform = \"XRSimulator\"\n case \"/tmp/tvOS_builds.plist\": platform = \"AppleTVSimulator\"\n case \"/tmp/macOS_builds.plist\": platform = \"MacOSX\"\n default: platform = \"iPhoneOS\"\n }\n var sdk = \"\\(xcodeDev)/Platforms/\\(platform).platform/Developer/SDKs/\\(platform).sdk\"\n if let match = Self.parsePlatform.firstMatch(in: compileCommand,\n options: [], range: NSMakeRange(0, compileCommand.utf16.count)) {\n func extract(group: Int, into: inout String) {\n if let range = Range(match.range(at: group), in: compileCommand) {\n into = compileCommand[range]\n .replacingOccurrences(of: #\"\\\\(.)\"#, with: \"$1\",\n options: .regularExpression)\n }\n }\n extract(group: 1, into: &sdk)\n extract(group: 2, into: &xcodeDev)\n extract(group: 4, into: &platform)\n } else if compileCommand.contains(\".swift \") {\n _ = evalError(\"Unable to parse SDK from: \\(compileCommand)\")\n }\n\n var osSpecific = \"\"\n switch platform {\n case \"iPhoneSimulator\":\n osSpecific = \"-mios-simulator-version-min=9.0\"\n case \"iPhoneOS\":\n osSpecific = \"-miphoneos-version-min=9.0\"\n case \"AppleTVSimulator\":\n osSpecific = \"-mtvos-simulator-version-min=9.0\"\n case \"AppleTVOS\":\n osSpecific = \"-mtvos-version-min=9.0\"\n case \"MacOSX\":\n let target = compileCommand\n .replacingOccurrences(of: #\"^.*( -target \\S+).*$\"#,\n with: \"$1\", options: .regularExpression)\n osSpecific = \"-mmacosx-version-min=10.11\"+target\n case \"XRSimulator\": fallthrough case \"XROS\":\n osSpecific = \"\"\n #if os(watchOS)\n case \"WatchSimulator\":\n osSpecific = \"\"\n #endif\n default:\n _ = evalError(\"Invalid platform \\(platform)\")\n // -Xlinker -bundle_loader -Xlinker \\\"\\(Bundle.main.executablePath!)\\\"\"\n }\n\n let toolchain = xcodeDev+\"/Toolchains/XcodeDefault.xctoolchain\"\n let cd = cd == \"\" ? \"\" : \"cd \\\"\\(cd)\\\" && \"\n if cd != \"\" && !contents.contains(arch) {\n _ = evalError(\"Modified object files \\(contents) not built for architecture \\(arch)\")\n }\n guard shell(command: \"\"\"\n \\(cd)\"\\(toolchain)/usr/bin/clang\" -arch \"\\(arch)\" \\\n -Xlinker -dylib -isysroot \"__PLATFORM__\" \\\n -L\"\\(toolchain)/usr/lib/swift/\\(platform.lowercased())\" \\(osSpecific) \\\n -undefined dynamic_lookup -dead_strip -Xlinker -objc_abi_version \\\n -Xlinker 2 -Xlinker -interposable\\(linkerOptions) -fobjc-arc \\\n -fprofile-instr-generate \\(contents) -L \"\\(frameworks)\" -F \"\\(frameworks)\" \\\n -rpath \"\\(frameworks)\" -o \\\"\\(dylib)\\\" >>\\\"\\(logfile)\\\" 2>&1\n \"\"\".replacingOccurrences(of: \"__PLATFORM__\", with: sdk)) else {\n throw scriptError(\"Linking\")\n }\n\n // codesign dylib\n\n if signer != nil {\n guard dylib.hasSuffix(Self.quickDylib) ||\n buildCacheFile == Self.simulatorCacheFile ||\n signer!(\"\\(injectionNumber).dylib\") else {\n #if SWIFT_PACKAGE\n throw evalError(\"Codesign failed. Consult /tmp/hot_reloading.log or Console.app\")\n #else\n throw evalError(\"Codesign failed, consult Console. If you are using macOS 11+, Please download a new release from https://github.com/johnno1962/InjectionIII/releases\")\n #endif\n }\n }\n else {\n #if os(iOS)\n // have to delegate code signing to macOS \"signer\" service\n guard (try? String(contentsOf: URL(string: \"http://localhost:8899\\(tmpfile).dylib\")!)) != nil else {\n throw evalError(\"Codesign failed. Is 'signer' daemon running?\")\n }\n #else\n guard shell(command: \"\"\"\n export CODESIGN_ALLOCATE=\\(xcodeDev)/Toolchains/XcodeDefault.xctoolchain/usr/bin/codesign_allocate; codesign --force -s '-' \"\\(tmpfile).dylib\"\n \"\"\") else {\n throw evalError(\"Codesign failed\")\n }\n #endif\n }\n\n // Rewrite dylib to prevent macOS 10.15+ from quarantining it\n let url = URL(fileURLWithPath: dylib)\n let dylib = try Data(contentsOf: url)\n try FileManager.default.removeItem(at: url)\n try dylib.write(to: url)\n }\n\n\n /// Regex for path argument, perhaps containg escaped spaces\n static let argumentRegex = #\"[^\\s\\\\]*(?:\\\\.[^\\s\\\\]*)*\"#\n /// Regex to extract filename base, perhaps containg escaped spaces\n static let fileNameRegex = #\"/(\\#(argumentRegex))\\.\\w+\"#\n /// Extract full file path and name either quoted or escaped\n static let filePathRegex =\n #\"\"/[^\"]*\\#(fileNameRegex)\"|/\\#(argumentRegex)\"#\n\n // Overridden in UnhidingEval.swift\n func xcode13Fix(sourceFile: String,\n compileCommand: inout String) -> String {\n // Trim off junk at end of compile command\n if sourceFile.hasSuffix(\".swift\") {\n compileCommand = compileCommand.replacingOccurrences(\n of: \" -o (\\(Self.filePathRegex))\",\n with: \"\", options: .regularExpression)\n .components(separatedBy: \" -index-system-modules\")[0]\n } else {\n compileCommand = compileCommand\n .components(separatedBy: \" -o \")[0]\n }\n if compileCommand.contains(\"/bazel \") {\n // force ld to fail as it is not needed\n compileCommand += \" --linkopt=-Wl,\"+skipBazelLinking\n // return path to workspace instead of object file\n return compileCommand[#\"^cd \"([^\"]+)\"\"#] ?? \"dir?\"\n }\n let objectFile = \"/tmp/injection_\\(injectionNumber).o\"\n compileCommand += \" -o \"+objectFile\n unlink(objectFile)\n return objectFile\n }\n\n func createUnhider(executable: String, _ objcClassRefs: NSMutableArray,\n _ descriptorRefs: NSMutableArray) {\n }\n\n #if !INJECTION_III_APP\n lazy var loadXCTest: () = {\n #if targetEnvironment(simulator)\n #if os(macOS)\n let sdk = \"MacOSX\"\n #elseif os(tvOS)\n let sdk = \"AppleTVSimulator\"\n #elseif targetEnvironment(simulator)\n let sdk = \"iPhoneSimulator\"\n #else\n let sdk = \"iPhoneOS\"\n #endif\n\n let platform = \"\\(xcodeDev)/Platforms/\\(sdk).platform/Developer/\"\n guard FileManager.default.fileExists(atPath: platform) else { return }\n\n if dlopen(platform+\"Library/Frameworks/XCTest.framework/XCTest\", RTLD_LAZY) == nil {\n debug(String(cString: dlerror()))\n }\n if dlopen(platform+\"usr/lib/libXCTestSwiftSupport.dylib\", RTLD_LAZY) == nil {\n debug(String(cString: dlerror()))\n }\n #else\n let copiedFrameworks = Bundle.main.bundlePath+\"/iOSInjection.bundle/Frameworks/\"\n for fw in [\"XCTestCore\", \"XCUnit\", \"XCUIAutomation\", \"XCTest\"] {\n if dlopen(copiedFrameworks+fw+\".framework/\\(fw)\", RTLD_LAZY) == nil {\n debug(String(cString: dlerror()))\n }\n }\n if dlopen(copiedFrameworks+\"libXCTestSwiftSupport.dylib\", RTLD_LAZY) == nil {\n debug(String(cString: dlerror()))\n }\n #endif\n }()\n\n lazy var loadTestsBundle: () = {\n do {\n guard let testsBundlePath = try testsBundlePath() else {\n debug(\"Tests bundle wasn't found - did you run the tests target before running the application?\")\n return\n }\n guard let bundle = Bundle(path: testsBundlePath), bundle.load() else {\n debug(\"Failed loading tests bundle\")\n return\n }\n } catch {\n debug(\"Error while searching for the tests bundle: \\(error)\")\n return\n }\n }()\n\n func testsBundlePath() throws -> String? {\n guard let pluginsDirectory = Bundle.main.path(forResource: \"PlugIns\", ofType: nil) else {\n return nil\n }\n\n let bundlePaths: [String] = try FileManager.default.contentsOfDirectory(atPath: pluginsDirectory)\n .filter { $0.hasSuffix(\".xctest\") }\n .map { directoryName in\n return \"\\(pluginsDirectory)/\\(directoryName)\"\n }\n if bundlePaths.count > 1 {\n debug(\"Found more than one tests bundle, using the first one\")\n }\n return bundlePaths.first\n }\n\n @objc func loadAndInject(tmpfile: String, oldClass: AnyClass? = nil)\n throws -> [AnyClass] {\n\n print(\"\\(APP_PREFIX)Loading .dylib ...\")\n // load patched .dylib into process with new version of class\n var dl: UnsafeMutableRawPointer?\n for dylib in \"\\(tmpfile).dylib\".components(separatedBy: Self.dylibDelim) {\n if let object = NSData(contentsOfFile: dylib),\n memmem(object.bytes, object.count, \"XCTest\", 6) != nil ||\n memmem(object.bytes, object.count, \"Quick\", 5) != nil,\n object.count != 0 {\n _ = loadXCTest\n _ = loadTestsBundle\n }\n #if canImport(SwiftTrace) || canImport(SwiftTraceD)\n dl = fast_dlopen(dylib, RTLD_NOW)\n #else\n dl = dlopen(dylib, RTLD_NOW)\n #endif\n guard dl != nil else {\n var error = String(cString: dlerror())\n if error.contains(\"___llvm_profile_runtime\") {\n error += \"\"\"\n \\n\\(APP_PREFIX)⚠️ Loading .dylib has failed, try turning off \\\n collection of test coverage in your scheme\n \"\"\"\n } else if error.contains(\"ymbol not found\") {\n error += \"\"\"\n \\n\\(APP_PREFIX)⚠️ Loading .dylib has failed, This is likely \\\n because Swift code being injected references a function \\\n using a default argument or a member with access control \\\n that is too restrictive or perhaps an XCTest that depends on \\\n code not normally linked into your application. Rebuilding and \\\n re-running your project (without a build clean) can resolve this.\n \"\"\"\n forceUnhide()\n } else if error.contains(\"code signature invalid\") {\n error += \"\"\"\n \\n\\(APP_PREFIX)⚠️ Loading .dylib has failed due to invalid code signing.\n \\(APP_PREFIX)Add the following as a Run Script/Build Phase:\n defaults write com.johnholdsworth.InjectionIII \"$PROJECT_FILE_PATH\" \"$EXPANDED_CODE_SIGN_IDENTITY\"\n \"\"\"\n } else if error.contains(\"rying to load an unsigned library\") {\n error += \"\"\"\n \\n\\(APP_PREFIX)⚠️ Loading .dylib in Xcode 15+ requires code signing.\n \\(APP_PREFIX)You will need to run the InjectionIII.app\n \"\"\"\n } else if error.contains(\"incompatible platform\") {\n error += \"\"\"\n \\n\\(APP_PREFIX)⚠️ Clean build folder when switching platform\n \"\"\"\n }\n throw evalError(\"dlopen() error: \\(error)\")\n }\n }\n\n if oldClass != nil {\n // find patched version of class using symbol for existing\n\n var info = Dl_info()\n guard dladdr(unsafeBitCast(oldClass, to: UnsafeRawPointer.self), &info) != 0 else {\n throw evalError(\"Could not locate class symbol\")\n }\n\n debug(String(cString: info.dli_sname))\n guard let newSymbol = dlsym(dl, info.dli_sname) else {\n throw evalError(\"Could not locate newly loaded class symbol\")\n }\n\n return [unsafeBitCast(newSymbol, to: AnyClass.self)]\n }\n else {\n // grep out symbols for classes being injected from object file\n\n return try extractClasses(dl: dl!, tmpfile: tmpfile)\n }\n }\n #endif\n\n func startUnhide() {\n }\n\n // Overridden by SwiftInjectionEval subclass for injection\n @objc func extractClasses(dl: UnsafeMutableRawPointer,\n tmpfile: String) throws -> [AnyClass] {\n guard shell(command: \"\"\"\n \\(xcodeDev)/Toolchains/XcodeDefault.xctoolchain/usr/bin/nm \\(tmpfile).o | \\\n grep -E ' S _OBJC_CLASS_\\\\$_| _(_T0|\\\\$S|\\\\$s).*CN$' | awk '{print $3}' \\\n >\\(tmpfile).classes\n \"\"\") else {\n throw evalError(\"Could not list class symbols\")\n }\n guard var classSymbolNames = (try? String(contentsOfFile:\n \"\\(tmpfile).classes\"))?.components(separatedBy: \"\\n\") else {\n throw evalError(\"Could not load class symbol list\")\n }\n classSymbolNames.removeLast()\n return Set(classSymbolNames.compactMap {\n dlsym(dl, String($0.dropFirst())) })\n .map { unsafeBitCast($0, to: AnyClass.self) }\n }\n\n func findCompileCommand(logsDir: URL, classNameOrFile: String, tmpfile: String)\n throws -> (compileCommand: String, sourceFile: String)? {\n // path to project can contain spaces and '$&(){}\n // Objective-C paths can only contain space and '\n // project file itself can only contain spaces\n let isFile = classNameOrFile.hasPrefix(\"/\")\n let sourceRegex = isFile ?\n #\"\\Q\\#(classNameOrFile)\\E\"# : #\"/\\#(classNameOrFile)\\.\\w+\"#\n let swiftEscaped = (isFile ? \"\" : #\"[^\"]*?\"#) + sourceRegex.escaping(\"'$\", with: #\"\\E\\\\*$0\\Q\"#)\n let objcEscaped = (isFile ? \"\" :\n #\"(?:/(?:[^/\\\\]*\\\\.)*[^/\\\\ ]+)+\"#) + sourceRegex.escaping()\n var regexp = #\" -(?:primary-file|c(?/dev/null |\" or die \"gnozip\";\n\n sub actualPath {\n \\#(actualPath)\n }\n\n sub recoverFilelist {\n my ($filemap) = $_[0] =~ / -output-file-map (\\#(\n Self.argumentRegex)) /;\n $filemap =~ s/\\\\//g;\n return if ! -s $filemap;\n my $file_handle = IO::File->new( \"< $filemap\" )\n or die \"Could not open filemap '$filemap'\";\n my $json_text = join'', $file_handle->getlines();\n return unless index($json_text, '\\#(sourceName)') > 0;\n my $json_map = decode_json( $json_text, { utf8 => 1 } );\n my $swift_sources = join \"\\n\", map { actualPath($_) } keys %$json_map;\n mkdir \"/tmp/filelists\";\n my $filelist = '/tmp/filelists/\\#(sourceName)';\n unlink $filelist;\n my $listfile = IO::File->new( \"> $filelist\" )\n or die \"Could not open list file '$filelist'\";\n binmode $listfile, ':utf8';\n $listfile->print( $swift_sources );\n $listfile->close();\n return $filelist;\n }\n\n # grep the log until there is a match\n my ($realPath, $command, $filelist);\n while (defined (my $line = )) {\n if ($line =~ /^\\s*cd /) {\n $realPath = $line;\n }\n elsif ($line =~ m@\\#(regexp.escaping(\"\\\"$\")\n .escaping(\"@\", with: #\"\\E\\$0\\Q\"#)\n )@oi and $line \\#(filterWatchOS)\n and $line =~ \"\\#(arch)\"\\#(swiftpm)) {\n # found compile command..\n # may need to recover file list\n my ($flarg) = $line =~ / -filelist (\\#(\n Self.argumentRegex))/;\n if ($flarg && ! -s $flarg) {\n while (defined (my $line2 = )) {\n if (my ($fl) = recoverFilelist($line2)) {\n $filelist = $fl;\n last;\n }\n }\n }\n if ($realPath and (undef, $realPath) =\n $realPath =~ /cd (\\\"?)(.*?)\\1\\r/) {\n $realPath =~ s/\\\\([^\\$])/$1/g;\n $line = \"cd \\\"$realPath\\\"; $line\";\n }\n # find last\n $command = $line;\n #exit 0;\n }\n elsif (my ($bazel, $dir) = $line =~ /^Running \"([^\"]+)\".* (?:patching output for workspace root|with project path) at (\"[^\"]+\")/) {\n $command = \"cd $dir && $bazel\";\n last;\n }\n elsif (my ($identity, $bundle) = $line =~ m@/usr/bin/codesign --force --sign (\\S+) --entitlements \\#(Self.argumentRegex) .+ (\\#(Self.argumentRegex))@) {\n $bundle =~ s/\\\\(.)/$1/g;\n unlink \"\\#(Self.bundleLink)\";\n symlink $bundle, \"\\#(Self.bundleLink)\";\n system \"rm -f ~/Library/Containers/com.johnholdsworth.InjectionIII/Data/Library/Preferences/com.johnholdsworth.InjectionIII.plist\"\n if $identity ne \"-\";\n system (qw(/usr/bin/env defaults write com.johnholdsworth.InjectionIII),\n '\\#(projectFile?.escaping(\"'\") ?? \"current project\")', $identity);\n }\n elsif (!$filelist &&\n index($line, \" -output-file-map \") > 0 and\n my ($fl) = recoverFilelist($line)) {\n $filelist = $fl;\n }\n }\n\n if ($command) {\n my ($flarg) = $command =~ / -filelist (\\#(\n Self.argumentRegex))/;\n if ($flarg && $filelist && ! -s $flarg) {\n $command =~ s/( -filelist )(\\#(\n Self.argumentRegex)) /$1'$filelist' /;\n }\n print $command;\n exit 0;\n }\n # class/file not found\n exit 1;\n \"\"\"#.write(toFile: \"\\(tmpfile).pl\",\n atomically: false, encoding: .utf8)\n\n guard shell(command: \"\"\"\n # search through build logs, most recent first\n cp \\(cmdfile) \\(cmdfile).save 2>/dev/null ; \\\n cd \"\\(logsDir.path.escaping(\"$\"))\" &&\n for log in `ls -t *.xcactivitylog`; do\n #echo \"Scanning $log\"\n /usr/bin/env perl \"\\(tmpfile).pl\" \"$log\" \\\n >\"\\(tmpfile).sh\" 2>>\"\\(tmpfile).err\" && exit 0\n done\n exit 1;\n \"\"\") else {\n #if targetEnvironment(simulator)\n if #available(iOS 14.0, tvOS 14.0, *) {\n } else {\n print(APP_PREFIX+\"\"\"\n ⚠️ Injection unable to search logs. \\\n Try a more recent iOS 14+ simulator \\\n or, download a release directly from \\\n https://github.com/johnno1962/InjectionIII/releases\n \"\"\")\n }\n #endif\n if let log = try? String(contentsOfFile: \"\\(tmpfile).err\"),\n !log.isEmpty {\n _ = evalError(\"stderr contains: \"+log)\n }\n return nil\n }\n\n var compileCommand: String\n do {\n compileCommand = try String(contentsOfFile: \"\\(tmpfile).sh\")\n } catch {\n throw evalError(\"\"\"\n Error reading \\(tmpfile).sh, scanCommand: \\(cmdfile)\n \"\"\")\n }\n\n// // escape ( & ) outside quotes\n// .replacingOccurrences(of: \"[()](?=(?:(?:[^\\\"]*\\\"){2})*[^\\\"]$)\", with: \"\\\\\\\\$0\", options: [.regularExpression])\n // (logs of new build system escape ', $ and \")\n debug(\"Found command:\", compileCommand)\n compileCommand = compileCommand.replacingOccurrences(of:\n #\"builtin-swift(DriverJob|Task)Execution --|-frontend-parseable-output|\\r$\"#,\n with: \"\", options: .regularExpression)\n// // remove excess escaping in new build system (no linger necessary)\n// .replacingOccurrences(of: #\"\\\\([\\\"'\\\\])\"#, with: \"$1\", options: [.regularExpression])\n // these files may no longer exist\n .replacingOccurrences(of:\n #\" -(pch-output-dir|supplementary-output-file-map|index-store-path|Xcc -ivfsstatcache -Xcc) \\#(Self.argumentRegex) \"#,\n with: \" \", options: .regularExpression)\n // Strip junk with Xcode 16.3 and EMIT_FRONTEND_COMMAND_LINES\n .replacingOccurrences(of: #\"^(.*?\"; )?\\S*?\"(?=/)\"#,\n with: \"\", options: .regularExpression)\n debug(\"Replaced command:\", compileCommand)\n\n if isFile {\n return (compileCommand, classNameOrFile)\n }\n\n // for eval() extract full path to file from compile command\n\n let fileExtractor: NSRegularExpression\n regexp = regexp.escaping(\"$\")\n\n do {\n fileExtractor = try NSRegularExpression(pattern: regexp, options: [])\n }\n catch {\n throw evalError(\"Regexp parse error: \\(error) -- \\(regexp)\")\n }\n\n guard let matches = fileExtractor\n .firstMatch(in: compileCommand, options: [],\n range: NSMakeRange(0, compileCommand.utf16.count)),\n var sourceFile = compileCommand[matches.range(at: 1)] ??\n compileCommand[matches.range(at: 2)] else {\n throw evalError(\"Could not locate source file \\(compileCommand) -- \\(regexp)\")\n }\n\n sourceFile = actualCase(path: sourceFile.unescape()) ?? sourceFile\n return (compileCommand, sourceFile)\n }\n\n func getAppCodeDerivedData(procPath: String) -> String {\n //Default with current year\n let derivedDataPath = { (year: Int, pathSelector: String) -> String in\n \"Library/Caches/\\(year > 2019 ? \"JetBrains/\" : \"\")\\(pathSelector)/DerivedData\"\n }\n\n let year = Calendar.current.component(.year, from: Date())\n let month = Calendar.current.component(.month, from: Date())\n\n let defaultPath = derivedDataPath(year, \"AppCode\\(month / 4 == 0 ? year - 1 : year).\\(month / 4 + (month / 4 == 0 ? 3 : 0))\")\n\n var plistPath = URL(fileURLWithPath: procPath)\n plistPath.deleteLastPathComponent()\n plistPath.deleteLastPathComponent()\n plistPath = plistPath.appendingPathComponent(\"Info.plist\")\n\n guard let dictionary = NSDictionary(contentsOf: plistPath) as? Dictionary else { return defaultPath }\n guard let jvmOptions = dictionary[\"JVMOptions\"] as? Dictionary else { return defaultPath }\n guard let properties = jvmOptions[\"Properties\"] as? Dictionary else { return defaultPath }\n guard let pathSelector: String = properties[\"idea.paths.selector\"] as? String else { return defaultPath }\n\n let components = pathSelector.replacingOccurrences(of: \"AppCode\", with: \"\").components(separatedBy: \".\")\n guard components.count == 2 else { return defaultPath }\n\n guard let realYear = Int(components[0]) else { return defaultPath }\n return derivedDataPath(realYear, pathSelector)\n }\n\n func findDerivedData(url: URL) -> URL? {\n if url.path == \"/\" {\n return nil\n }\n\n var relativeDirs = [\"DerivedData\", \"build/DerivedData\"]\n if lastIdeProcPath.lowercased().contains(\"appcode\") {\n relativeDirs.append(getAppCodeDerivedData(procPath: lastIdeProcPath))\n } else {\n relativeDirs.append(\"Library/Developer/Xcode/DerivedData\")\n }\n for relative in relativeDirs {\n let derived = url.appendingPathComponent(relative)\n if FileManager.default.fileExists(atPath: derived.path) {\n return derived\n }\n }\n\n return findDerivedData(url: url.deletingLastPathComponent())\n }\n\n func findProject(for source: URL, derivedData: URL) -> (projectFile: URL, logsDir: URL)? {\n let dir = source.deletingLastPathComponent()\n if dir.path == \"/\" {\n return nil\n }\n\n if bazelLight {\n let workspaceURL = dir.deletingLastPathComponent()\n .appendingPathComponent(bazelWorkspace)\n if FileManager.default.fileExists(atPath: workspaceURL.path) {\n return (workspaceURL, derivedLogs.flatMap({\n URL(fileURLWithPath: $0)}) ?? dir)\n }\n }\n\n var candidate = findProject(for: dir, derivedData: derivedData)\n if let files =\n try? FileManager.default.contentsOfDirectory(atPath: dir.path),\n let project = Self.projects(in: files)?.first,\n let logsDir = logsDir(project: dir.appendingPathComponent(project), derivedData: derivedData),\n mtime(logsDir) > candidate.flatMap({ mtime($0.logsDir) }) ?? 0 {\n candidate = (dir.appendingPathComponent(project), logsDir)\n }\n\n return candidate\n }\n\n class func projects(in files: [String]) -> [String]? {\n return names(withSuffix: \".xcworkspace\", in: files) ??\n names(withSuffix: \".xcodeproj\", in: files) ??\n names(withSuffix: \"Package.swift\", in: files)\n }\n\n class func names(withSuffix ext: String, in files: [String]) -> [String]? {\n let matches = files.filter { $0.hasSuffix(ext) }\n return matches.count != 0 ? matches : nil\n }\n\n func mtime(_ url: URL) -> time_t {\n var info = stat()\n return stat(url.path, &info) == 0 ? info.st_mtimespec.tv_sec : 0\n }\n\n func logsDir(project: URL, derivedData: URL) -> URL? {\n let filemgr = FileManager.default\n var projectPrefix = project.deletingPathExtension().lastPathComponent\n if project.lastPathComponent == \"Package.swift\" {\n projectPrefix = project.deletingLastPathComponent().lastPathComponent\n }\n projectPrefix = projectPrefix.replacingOccurrences(of: #\"\\s+\"#, with: \"_\",\n options: .regularExpression, range: nil)\n let derivedDirs = (try? filemgr\n .contentsOfDirectory(atPath: derivedData.path)) ?? []\n let namedDirs = derivedDirs\n .filter { $0.starts(with: projectPrefix + \"-\") }\n var possibleDerivedData = (namedDirs.isEmpty ? derivedDirs : namedDirs)\n .map { derivedData.appendingPathComponent($0 + \"/Logs/Build\") }\n possibleDerivedData.append(project.deletingLastPathComponent()\n .appendingPathComponent(\"DerivedData/\\(projectPrefix)/Logs/Build\"))\n debug(\"Possible DerivedDatas: \\(possibleDerivedData)\")\n\n // use most recentry modified\n return possibleDerivedData\n .filter { filemgr.fileExists(atPath: $0.path) }\n .sorted { mtime($0) > mtime($1) }\n .first\n }\n\n class func uniqueTypeNames(signatures: [String], exec: (String) -> Void) {\n var typesSearched = Set()\n\n for signature in signatures {\n let parts = signature.components(separatedBy: \".\")\n if parts.count < 3 {\n continue\n }\n let typeName = parts[1]\n if typesSearched.insert(typeName).inserted {\n exec(typeName)\n }\n }\n }\n\n func shell(command: String) -> Bool {\n try! command.write(toFile: cmdfile, atomically: false, encoding: .utf8)\n debug(command)\n\n #if os(macOS)\n let task = Process()\n task.launchPath = \"/bin/bash\"\n task.arguments = [cmdfile]\n task.launch()\n task.waitUntilExit()\n let status = task.terminationStatus\n #else\n let status = runner.run(script: cmdfile)\n #endif\n return status == EXIT_SUCCESS\n }\n\n #if !os(macOS)\n lazy var runner = ScriptRunner()\n\n class ScriptRunner {\n let commandsOut: UnsafeMutablePointer\n let statusesIn: UnsafeMutablePointer\n\n init() {\n let ForReading = 0, ForWriting = 1\n var commandsPipe = [Int32](repeating: 0, count: 2)\n var statusesPipe = [Int32](repeating: 0, count: 2)\n pipe(&commandsPipe)\n pipe(&statusesPipe)\n\n var envp = [UnsafeMutablePointer?](repeating: nil, count: 2)\n if let home = getenv(\"USER_HOME\") {\n envp[0] = strdup(\"HOME=\\(home)\")!\n }\n\n if fork() == 0 {\n let commandsIn = fdopen(commandsPipe[ForReading], \"r\")\n let statusesOut = fdopen(statusesPipe[ForWriting], \"w\")\n var buffer = [Int8](repeating: 0, count: Int(MAXPATHLEN))\n\n close(commandsPipe[ForWriting])\n close(statusesPipe[ForReading])\n setbuf(statusesOut, nil)\n\n while let script = fgets(&buffer, Int32(buffer.count), commandsIn) {\n script[strlen(script)-1] = 0\n\n let pid = fork()\n if pid == 0 {\n var argv = [UnsafeMutablePointer?](repeating: nil, count: 3)\n argv[0] = strdup(\"/bin/bash\")!\n argv[1] = strdup(script)!\n _ = execve(argv[0], &argv, &envp)\n fatalError(\"execve() fails \\(String(cString: strerror(errno)))\")\n }\n\n var status: Int32 = 0\n while waitpid(pid, &status, 0) == -1 {}\n fputs(\"\\(status)\\n\", statusesOut)\n }\n\n exit(0)\n }\n\n commandsOut = fdopen(commandsPipe[ForWriting], \"w\")\n statusesIn = fdopen(statusesPipe[ForReading], \"r\")\n\n close(commandsPipe[ForReading])\n close(statusesPipe[ForWriting])\n setbuf(commandsOut, nil)\n }\n\n func run(script: String) -> Int32 {\n fputs(\"\\(script)\\n\", commandsOut)\n var buffer = [Int8](repeating: 0, count: 20)\n fgets(&buffer, Int32(buffer.count), statusesIn)\n let status = atoi(buffer)\n return status >> 8 | status & 0xff\n }\n }\n #endif\n\n #if DEBUG\n deinit {\n print(\"\\(self).deinit()\")\n }\n #endif\n}\n\n@_silgen_name(\"fork\")\nfunc fork() -> Int32\n@_silgen_name(\"execve\")\nfunc execve(_ __file: UnsafePointer!,\n _ __argv: UnsafePointer?>!,\n _ __envp: UnsafePointer?>!) -> Int32\n#endif\n#endif\n"
},
{
"path": "Sources/HotReloading/SwiftInjection.swift",
"content": "//\n// SwiftInjection.swift\n// InjectionBundle\n//\n// Created by John Holdsworth on 05/11/2017.\n// Copyright © 2017 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/SwiftInjection.swift#223 $\n//\n// Cut-down version of code injection in Swift. Uses code\n// from SwiftEval.swift to recompile and reload class.\n//\n// There is a lot of history in this file. Originaly injection for Swift\n// worked by patching the vtable of non final classes which worked fairly\n// well but then we discovered \"interposing\" which is a mechanisim used by\n// the dynamic linker to resolve references to system frameworks that can\n// be used to rebind symbols at run time if you use the -interposable linker\n// flag. This meant we were able to support injecting final methods of classes\n// and methods of structs and enums. The code still updates the vtable though.\n//\n// A more recent change is to better supprt injection of generic classes\n// and classes that inherit from generics which causes problems (crashes) in\n// the Objective-C runtime. As one can't anticipate the specialisation of\n// a generic in use from the object file (.dylib) alone, the patching of the\n// vtable has been moved to the being a part of the sweep which means you need\n// to have a live object of that specialisation for class injection to work.\n//\n// Support was also added to use injection with projects using \"The Composable\n// Architecture\" (TCA) though you need to use a modified version of the repo:\n// https://github.com/thebrowsercompany/swift-composable-architecture/tree/develop\n//\n// InjectionIII.app now supports injection of class methods, getters and setters\n// and can maintain the values of top level and static variables when they are\n// injected instead of their being reinitialised as the object file is reloaded.\n//\n// Which Swift symbols can be patched or interposed is now centralised and\n// configurable using the closure SwiftTrace.injectableSymbol which has been\n// extended to include async functions which, while they can be injected, can\n// never be traced due to changes in the stack layout when using co-routines.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\n#if arch(x86_64) || arch(i386) || arch(arm64) // simulator/macOS only\nimport Foundation\n#if SWIFT_PACKAGE\n@_exported import SwiftTraceD\n#else\n@_exported import SwiftTrace\n#endif\n\n#if os(iOS) || os(tvOS)\nimport UIKit\n\nextension UIViewController {\n\n /// inject a UIView controller and redraw\n public func injectVC() {\n injectSelf()\n for subview in self.view.subviews {\n subview.removeFromSuperview()\n }\n if let sublayers = self.view.layer.sublayers {\n for sublayer in sublayers {\n sublayer.removeFromSuperlayer()\n }\n }\n viewDidLoad()\n }\n}\n#endif\n\nextension NSObject {\n\n public func injectSelf() {\n if let oldClass: AnyClass = object_getClass(self) {\n SwiftInjection.inject(oldClass: oldClass, classNameOrFile: \"\\(oldClass)\")\n }\n }\n\n @objc\n public class func inject(file: String) {\n SwiftInjection.inject(classNameOrFile: file)\n }\n}\n\n@objc(SwiftInjection)\npublic class SwiftInjection: NSObject {\n\n public typealias SymbolName = UnsafePointer\n @objc static var traceInjection = false\n\n static let testQueue = DispatchQueue(label: \"INTestQueue\")\n static let injectedSEL = #selector(SwiftInjected.injected)\n #if os(iOS) || os(tvOS)\n static let viewDidLoadSEL = #selector(UIViewController.viewDidLoad)\n #endif\n static let notification = Notification.Name(INJECTION_BUNDLE_NOTIFICATION)\n\n static var injectionDetail = getenv(INJECTION_DETAIL) != nil\n static let registerClasses = false && SwiftTrace.deviceInjection\n static var objcClassRefs = NSMutableArray()\n static var descriptorRefs = NSMutableArray()\n static var injectedPrefix: String {\n return \"#\\(SwiftEval.instance.injectionNumber-100)/\"\n }\n\n open class func log(_ what: Any...) {\n print(APP_PREFIX+what.map {\"\\($0)\"}.joined(separator: \" \"))\n }\n open class func detail(_ msg: @autoclosure () -> String) {\n if injectionDetail {\n log(msg())\n }\n }\n\n @objc\n open class func inject(oldClass: AnyClass? = nil, classNameOrFile: String) {\n do {\n let tmpfile = try SwiftEval.instance.rebuildClass(oldClass: oldClass,\n classNameOrFile: classNameOrFile, extra: nil)\n try inject(tmpfile: tmpfile)\n }\n catch {\n SwiftEval.instance.updateLongTermCache(remove: classNameOrFile)\n }\n }\n\n @objc\n open class func replayInjections() -> Int {\n do {\n func mtime(_ path: String) -> time_t {\n return SwiftEval.instance.mtime(URL(fileURLWithPath: path))\n }\n let execBuild = mtime(Bundle.main.executablePath!)\n\n while true {\n SwiftEval.instance.injectionNumber += 1\n let tmpfile = SwiftEval.instance.tmpfile\n if mtime(\"\\(tmpfile).dylib\") < execBuild {\n SwiftEval.instance.injectionNumber -= 1\n break\n }\n try inject(tmpfile: tmpfile)\n }\n }\n catch {\n }\n return SwiftEval.instance.injectionNumber\n }\n\n open class func versions(of aClass: AnyClass) -> [AnyClass] {\n var out = [AnyClass](), nc: UInt32 = 0, info = Dl_info()\n if let classes = UnsafePointer(objc_copyClassList(&nc)) {\n let named = _typeName(aClass)\n for i in 0 ..< Int(nc) {\n if class_getSuperclass(classes[i]) != nil && classes[i] != aClass,\n _typeName(classes[i]) == named,\n !(registerClasses &&\n dladdr(autoBitCast(classes[i]), &info) != 0 &&\n strcmp(info.dli_sname, \"injected_code\") == 0) {\n out.append(classes[i])\n }\n }\n free(UnsafeMutableRawPointer(mutating: classes))\n }\n return out\n }\n\n @objc\n open class func inject(tmpfile: String) throws {\n try inject(tmpfile: tmpfile, newClasses:\n SwiftEval.instance.loadAndInject(tmpfile: tmpfile))\n }\n\n @objc\n open class func inject(tmpfile: String, newClasses: [AnyClass]) throws {\n var totalPatched = 0, totalSwizzled = 0\n var injectedGenerics = Set()\n var injectedClasses = [AnyClass]()\n var sweepClasses = [AnyClass]()\n var testClasses = [AnyClass]()\n\n injectionDetail = getenv(INJECTION_DETAIL) != nil\n SwiftTrace.preserveStatics = getenv(INJECTION_PRESERVE_STATICS) != nil\n if getenv(INJECTION_TRACE) != nil {\n traceInjection = true\n SwiftTrace.typeLookup = true\n }\n\n // Determine any generic classes being injected.\n findSwiftSymbols(searchLastLoaded(), \"CMa\") {\n accessor, symname, _, _ in\n if let demangled = SwiftMeta.demangle(symbol: symname),\n let genericClassName = demangled[safe: (.last(of: \" \")+1)...],\n !genericClassName.hasPrefix(\"__C.\") {\n injectedGenerics.insert(genericClassName)\n }\n }\n\n #if !targetEnvironment(simulator) && SWIFT_PACKAGE && canImport(InjectionScratch)\n if let pseudoImage = lastPseudoImage() {\n fillinObjcClassMetadata(in: pseudoImage)\n }\n #endif\n\n // First, the old way for non-generics\n for var newClass: AnyClass in newClasses {\n let className = _typeName(newClass)\n detail(\"Processing class \\(className)\")\n var oldClasses = versions(of: newClass)\n injectedGenerics.remove(className)\n if oldClasses.isEmpty {\n var info = Dl_info()\n if dladdr(autoBitCast(newClass), &info) != 0,\n let symbol = info.dli_sname,\n let oldClass = dlsym(SwiftMeta.RTLD_MAIN_ONLY, symbol) {\n oldClasses.append(autoBitCast(oldClass))\n }\n }\n sweepClasses += oldClasses\n\n for var oldClass: AnyClass in oldClasses {\n let oldClassName = _typeName(oldClass) +\n String(format: \" %p\", unsafeBitCast(oldClass, to: uintptr_t.self))\n #if true\n let patched = patchSwiftVtable(oldClass: oldClass, newClass: newClass)\n #else\n let patched = newPatchSwiftVtable(oldClass: oldClass, tmpfile: tmpfile)\n #endif\n\n if patched != 0 {\n totalPatched += patched\n\n let existingClass = unsafeBitCast(oldClass, to:\n UnsafeMutablePointer.self)\n let classMetadata = unsafeBitCast(newClass, to:\n UnsafeMutablePointer.self)\n\n // Old mechanism for Swift equivalent of \"Swizzling\".\n if classMetadata.pointee.ClassAddressPoint != existingClass.pointee.ClassAddressPoint {\n log(\"\"\"\n ⚠️ Mixing Xcode versions across injection. This may work \\\n but \"Clean Builder Folder\" when switching Xcode versions. \\\n To clear the cache: rm \\(SwiftEval.instance.buildCacheFile)\n \"\"\")\n } else\n if classMetadata.pointee.ClassSize != existingClass.pointee.ClassSize {\n log(\"\"\"\n ⚠️ Adding or [re]moving methods of non-final class \\\n \\(oldClass)[\\(existingClass.pointee.ClassSize)],\\\n \\(newClass)[\\(classMetadata.pointee.ClassSize)] \\\n is not supported. Your application will likely crash. \\\n Paradoxically, you can avoid this by making the class \\\n you are trying to inject (and add methods to) \"final\". ⚠️\n \"\"\")\n }\n }\n\n // Is there a generic superclass?\n if inheritedGeneric(anyType: oldClass) {\n // fallback to limited processing avoiding objc runtime.\n // (object_getClass() and class_copyMethodList() crash)\n let swizzled = swizzleBasics(oldClass: oldClass, tmpfile: tmpfile)\n totalSwizzled += swizzled\n detail(\"Injected class '\\(oldClassName)' (\\(patched),\\(swizzled)).\")\n continue\n }\n\n if oldClass == newClass {\n if oldClasses.count > 1 {\n oldClass = oldClasses.first!\n newClass = oldClasses.last!\n } else {\n log(\"⚠️ Could not find versions of class \\(_typeName(newClass)). ⚠️\")\n }\n }\n\n var swizzled: Int\n if !SwiftTrace.deviceInjection || registerClasses {\n // old-school swizzle Objective-C class & instance methods\n swizzled = injection(swizzle: object_getClass(oldClass),\n from: object_getClass(newClass)) +\n injection(swizzle: oldClass, from: newClass)\n } else {\n #if !targetEnvironment(simulator) && SWIFT_PACKAGE && canImport(InjectionScratch)\n swizzled = onDevice(swizzle: oldClass, from: newClass)\n #else\n swizzled = injection(swizzle: object_getClass(oldClass)!,\n tmpfile: tmpfile) +\n injection(swizzle: oldClass, tmpfile: tmpfile)\n #endif\n }\n totalSwizzled += swizzled\n\n detail(\"Patched class '\\(oldClassName)' (\\(patched),\\(swizzled))\")\n }\n\n if let XCTestCase = objc_getClass(\"XCTestCase\") as? AnyClass,\n isSubclass(newClass, of: XCTestCase) {\n testClasses.append(newClass)\n }\n\n injectedClasses.append(newClass)\n }\n\n #if !SWIFT_PACKAGE\n let patchedGenerics = hookedPatch(of: injectedGenerics, tmpfile: tmpfile)\n totalPatched += patchedGenerics.count\n sweepClasses += patchedGenerics\n #endif\n\n // (Reverse) interposing, reducers, operation on a device etc.\n let totalInterposed = newerProcessing(tmpfile: tmpfile, sweepClasses)\n lastLoadedImage().symbols(withPrefix: \"__OBJC_$_CATEGORY_\") {_,_,_ in\n totalSwizzled += 1\n }\n if totalPatched + totalSwizzled + totalInterposed + testClasses.count == 0 {\n log(\"⚠️ Injection may have failed. Have you added -Xlinker -interposable (for the Debug configuration only, without double quotes and on separate lines) to the \\\"Other Linker Flags\\\" of the executable and frameworks? ⚠️\")\n }\n\n DispatchQueue.main.async {\n // Thanks https://github.com/johnno1962/injectionforxcode/pull/234\n if !testClasses.isEmpty {\n testQueue.async {\n testQueue.suspend()\n let timer = Timer(timeInterval: 0, repeats:false, block: { _ in\n for newClass in testClasses {\n NSObject.runXCTestCase(newClass)\n }\n testQueue.resume()\n })\n RunLoop.main.add(timer, forMode: RunLoop.Mode.common)\n }\n } else { // implement class and instance injected() methods\n if !SwiftTrace.deviceInjection {\n typealias ClassIMP = @convention(c) (AnyClass, Selector) -> ()\n for cls in injectedClasses {\n if let classMethod = class_getClassMethod(cls, injectedSEL) {\n let classIMP = method_getImplementation(classMethod)\n unsafeBitCast(classIMP, to: ClassIMP.self)(cls, injectedSEL)\n }\n }\n }\n performSweep(oldClasses: sweepClasses, tmpfile,\n getenv(INJECTION_OF_GENERICS) != nil ? injectedGenerics : [])\n\n NotificationCenter.default.post(name: notification, object: sweepClasses)\n }\n }\n }\n\n open class func isSubclass(_ subClass: AnyClass, of aClass: AnyClass) -> Bool {\n var subClass: AnyClass? = subClass\n repeat {\n if subClass == aClass {\n return true\n }\n subClass = class_getSuperclass(subClass)\n } while subClass != nil\n return false\n }\n\n open class func inheritedGeneric(anyType: Any.Type) -> Bool {\n var inheritedGeneric: AnyClass? = anyType as? AnyClass\n if class_getSuperclass(inheritedGeneric) == nil {\n return true\n }\n while let parent = inheritedGeneric {\n if _typeName(parent).hasSuffix(\">\") {\n return true\n }\n inheritedGeneric = class_getSuperclass(parent)\n }\n return false\n }\n\n open class func newerProcessing(tmpfile: String,\n _ sweepClasses: [AnyClass]) -> Int {\n // new mechanism for injection of Swift functions,\n // using \"interpose\" API from dynamic loader along\n // with -Xlinker -interposable \"Other Linker Flags\".\n let interposed = Set(interpose(functionsIn: \"\\(tmpfile).dylib\"))\n if interposed.count != 0 {\n for symname in interposed {\n detail(\"Interposed \"+describeImageSymbol(symname))\n }\n log(\"Interposed \\(interposed.count) function references.\")\n }\n\n #if !targetEnvironment(simulator) && SWIFT_PACKAGE && canImport(InjectionScratch)\n if let pseudoImage = lastPseudoImage() {\n onDeviceSpecificProcessing(for: pseudoImage, sweepClasses)\n }\n #endif\n\n // Can prevent statics from re-initializing on injection\n reverseInterposeStaticsAddressors(tmpfile)\n\n // log any types being injected\n var ntypes = 0, npreviews = 0\n findSwiftSymbols(searchLastLoaded(), \"N\") {\n (typePtr, symbol, _, _) in\n if let existing: Any.Type =\n autoBitCast(dlsym(SwiftMeta.RTLD_DEFAULT, symbol)) {\n let name = _typeName(existing)\n if name.hasSuffix(\"_Previews\") {\n npreviews += 1\n }\n if name.hasSuffix(\"PreviewRegistryfMu_\") {\n return\n }\n ntypes += 1\n log(\"Injected type #\\(ntypes) '\\(name)'\")\n if SwiftTrace.deviceInjection {\n SwiftMeta.cloneValueWitness(from: existing, onto: autoBitCast(typePtr))\n }\n let newSize = SwiftMeta.sizeof(anyType: autoBitCast(typePtr))\n if newSize != 0 && newSize != SwiftMeta.sizeof(anyType: existing) {\n log(\"⚠️ Size of value type \\(_typeName(existing)) has changed (\\(newSize) != \\(SwiftMeta.sizeof(anyType: existing))). You cannot inject changes to memory layout. This will likely just crash. ⚠️\")\n }\n }\n }\n\n if false && npreviews > 0 && ntypes > 2 && SwiftTrace.deviceInjection {\n log(\"⚠️ Device injection may fail if you have more than one type from the injected file referred to in a SwiftUI View.\")\n }\n\n if getenv(INJECTION_DYNAMIC_CAST) != nil {\n // Cater for dynamic cast (i.e. as?) to types that have been injected.\n DynamicCast.hook_lastInjected()\n }\n\n var reducers = [SymbolName]()\n if !injectableReducerSymbols.isEmpty {\n reinitializeInjectedReducers(tmpfile, reinitialized: &reducers)\n let s = reducers.count == 1 ? \"\" : \"s\"\n log(\"Overrode \\(reducers.count) reducer\"+s)\n }\n\n return interposed.count + reducers.count\n }\n\n #if true // Original version of vtable patch, headed for retirement..\n /// Patch entries in vtable of existing class to be that in newly loaded version of class for non-final methods\n class func patchSwiftVtable(oldClass: AnyClass, newClass: AnyClass) -> Int {\n // overwrite Swift vtable of existing class with implementations from new class\n let existingClass = unsafeBitCast(oldClass, to:\n UnsafeMutablePointer.self)\n let classMetadata = unsafeBitCast(newClass, to:\n UnsafeMutablePointer.self)\n\n // Is this a Swift class?\n // Reference: https://github.com/apple/swift/blob/master/include/swift/ABI/Metadata.h#L1195\n let oldSwiftCondition = classMetadata.pointee.Data & 0x1 == 1\n let newSwiftCondition = classMetadata.pointee.Data & 0x3 != 0\n\n guard newSwiftCondition || oldSwiftCondition else { return 0 }\n var patched = 0\n\n #if true // supplimented by \"interpose\" code\n // vtable still needs to be patched though for non-final methods\n func byteAddr(_ location: UnsafeMutablePointer) -> UnsafeMutablePointer {\n return location.withMemoryRebound(to: UInt8.self, capacity: 1) { $0 }\n }\n\n let vtableOffset = byteAddr(&existingClass.pointee.IVarDestroyer) - byteAddr(existingClass)\n\n #if false\n // Old mechanism for Swift equivalent of \"Swizzling\".\n if classMetadata.pointee.ClassSize != existingClass.pointee.ClassSize {\n log(\"⚠️ Adding or [re]moving methods on non-final classes is not supported. Your application will likely crash. ⚠️\")\n }\n\n // original injection implementaion for Swift.\n let vtableLength = Int(existingClass.pointee.ClassSize -\n existingClass.pointee.ClassAddressPoint) - vtableOffset\n\n memcpy(byteAddr(existingClass) + vtableOffset,\n byteAddr(classMetadata) + vtableOffset, vtableLength)\n #else\n // new version only copying only symbols that are functions.\n let newTable = (byteAddr(classMetadata) + vtableOffset)\n .withMemoryRebound(to: SwiftTrace.SIMP?.self, capacity: 1) { $0 }\n\n SwiftTrace.iterateMethods(ofClass: oldClass) {\n (name, slotIndex, vtableSlot, stop) in\n if let replacement = SwiftTrace.interposed(replacee:\n autoBitCast(newTable[slotIndex] ?? vtableSlot.pointee)),\n autoBitCast(vtableSlot.pointee) != replacement {\n traceAndReplace(vtableSlot.pointee,\n replacement: replacement, name: name) {\n (replacement: UnsafeMutableRawPointer) -> String? in\n vtableSlot.pointee = autoBitCast(replacement)\n if autoBitCast(vtableSlot.pointee) == replacement { ////\n patched += 1\n return newTable[slotIndex] != nil ? \"Patched\" : \"Populated\"\n }\n return nil\n }\n }\n }\n #endif\n #endif\n return patched\n }\n #endif\n\n /// Newer way to patch vtable looking up existing entries individually in newly loaded dylib.\n open class func newPatchSwiftVtable(oldClass: AnyClass,// newClass: AnyClass?,\n tmpfile: String) -> Int {\n var patched = 0\n\n SwiftTrace.forEachVTableEntry(ofClass: oldClass) {\n (symname, slotIndex, vtableSlot, stop) in\n let existing: UnsafeMutableRawPointer = autoBitCast(vtableSlot.pointee)\n guard let replacement = fast_dlsym(lastLoadedImage(), symname) ??\n (dlsym(SwiftMeta.RTLD_DEFAULT, symname) ??\n findSwiftSymbol(searchBundleImages(), symname, .any)).flatMap({\n autoBitCast(SwiftTrace.interposed(replacee: $0)) }) else {\n log(\"⚠️ Class patching failed to lookup \" +\n describeImageSymbol(symname))\n return\n }\n if replacement != existing {\n traceAndReplace(existing, replacement: replacement, symname: symname) {\n (replacement: UnsafeMutableRawPointer) -> String? in\n vtableSlot.pointee = autoBitCast(replacement)\n if autoBitCast(vtableSlot.pointee) == replacement {\n patched += 1\n return \"Patched\"\n }\n return nil\n }\n }\n }\n\n return patched\n }\n\n /// Pop a trace on a newly injected method and convert the pointer type while you're at it\n open class func traceInjected(replacement: IN, name: String? = nil,\n symname: UnsafePointer? = nil,\n objcMethod: Method? = nil, objcClass: AnyClass? = nil)\n -> UnsafeRawPointer {\n if traceInjection || SwiftTrace.isTracing,\n let name = name ??\n symname.flatMap({ SwiftMeta.demangle(symbol: $0) }) ??\n objcMethod.flatMap({ NSStringFromSelector(method_getName($0)) }),\n !name.contains(\".unsafeMutableAddressor :\"),\n let tracer = SwiftTrace.trace(name: injectedPrefix + name,\n objcMethod: objcMethod, objcClass: objcClass,\n original: autoBitCast(replacement)) {\n return autoBitCast(tracer)\n }\n return autoBitCast(replacement)\n }\n\n /// All implementation replacements go through this function which can also apply a trace\n /// - Parameters:\n /// - existing: implementation being replaced\n /// - replacement: new implementation\n /// - name: demangled symbol for trace\n /// - symname: raw symbol nme\n /// - objcMethod: used for trace\n /// - objcClass: used for trace\n /// - apply: closure to apply replacement\n open class func traceAndReplace(_ existing: E,\n replacement: UnsafeRawPointer,\n name: String? = nil, symname: UnsafePointer? = nil,\n objcMethod: Method? = nil, objcClass: AnyClass? = nil,\n apply: (O) -> String?) {\n let traced = traceInjected(replacement: replacement, name: name,\n symname: symname, objcMethod: objcMethod, objcClass: objcClass)\n\n // injecting getters returning generics best avoided for some reason.\n if let getted = name?[safe: .last(of: \".getter : \", end: true)...] {\n if getted.hasSuffix(\">\") { return }\n if let type = SwiftMeta.lookupType(named: getted),\n inheritedGeneric(anyType: type) {\n return\n }\n }\n if let success = apply(autoBitCast(traced)) {\n detail(\"\\(success) \\(autoBitCast(existing) as UnsafeRawPointer) -> \\(replacement) \" + describeImagePointer(replacement))\n }\n }\n\n /// Resolve a perhaps traced function back to name of original symbol\n open class func originalSym(for existing: UnsafeMutableRawPointer) -> SymbolName? {\n var info = Dl_info()\n if fast_dladdr(existing, &info) != 0 {\n return info.dli_sname\n } else if let swizzle = SwiftTrace.originalSwizzle(for: autoBitCast(existing)),\n fast_dladdr(autoBitCast(swizzle.implementation), &info) != 0 {\n return info.dli_sname\n }\n return nil\n }\n\n /// If class is a generic, patch its specialised vtable and basic selectors\n open class func patchGenerics(oldClass: AnyClass, tmpfile: String,\n injectedGenerics: Set,\n patched: inout Set) -> Bool {\n if let genericClassName = _typeName(oldClass)[safe: ..<(.first(of: \"<\"))],\n injectedGenerics.contains(genericClassName) {\n if patched.insert(autoBitCast(oldClass)).inserted {\n let patched = newPatchSwiftVtable(oldClass: oldClass, tmpfile: tmpfile)\n let swizzled = swizzleBasics(oldClass: oldClass, tmpfile: tmpfile)\n log(\"Injected generic '\\(oldClass)' (\\(patched),\\(swizzled))\")\n }\n return oldClass.instancesRespond(to: injectedSEL)\n }\n return false\n }\n\n @objc(vaccine:)\n open class func performVaccineInjection(_ object: AnyObject) {\n #if !os(watchOS)\n let vaccine = Vaccine()\n vaccine.performInjection(on: object)\n #endif\n }\n\n #if os(iOS) || os(tvOS)\n @objc(flash:)\n open class func flash(vc: UIViewController) {\n DispatchQueue.main.async {\n let v = UIView(frame: vc.view.frame)\n v.backgroundColor = .white\n v.alpha = 0.3\n vc.view.addSubview(v)\n UIView.animate(withDuration: 0.2,\n delay: 0.0,\n options: UIView.AnimationOptions.curveEaseIn,\n animations: {\n v.alpha = 0.0\n }, completion: { _ in v.removeFromSuperview() })\n }\n }\n #endif\n}\n\n@objc\npublic class SwiftInjectionEval: UnhidingEval {\n\n @objc override open class func sharedInstance() -> SwiftEval {\n SwiftEval.instance = SwiftInjectionEval()\n return SwiftEval.instance\n }\n\n @objc override open func extractClasses(dl: UnsafeMutableRawPointer,\n tmpfile: String) throws -> [AnyClass] {\n var classes = [AnyClass]()\n SwiftTrace.forAllClasses(bundlePath: searchLastLoaded()) {\n aClass, stop in\n classes.append(aClass)\n }\n if classes.count > 0 && !SwiftTrace.deviceInjection {\n print(\"\\(APP_PREFIX)Loaded .dylib - Ignore any duplicate class warning ⬆️\")\n }\n #if false // Just too dubious\n // Determine any generic classes being injected.\n // (Done as part of sweep in the end.)\n findSwiftSymbols(searchLastLoaded(), \"CMa\") {\n accessor, _, _, _ in\n struct Something {}\n typealias AF = @convention(c) (UnsafeRawPointer, UnsafeRawPointer) -> UnsafeRawPointer\n let tmd: Any.Type = Void.self\n let tmd0 = unsafeBitCast(tmd, to: UnsafeRawPointer.self)\n let tmd1 = unsafeBitCast(accessor, to: AF.self)(tmd0, tmd0)\n let tmd2 = unsafeBitCast(tmd1, to: Any.Type.self)\n if let genericClass = tmd2 as? AnyClass {\n classes.append(genericClass)\n }\n }\n #endif\n return classes\n }\n}\n#endif\n#endif\n"
},
{
"path": "Sources/HotReloading/SwiftInterpose.swift",
"content": "//\n// SwiftInterpose.swift\n//\n// Created by John Holdsworth on 25/04/2022.\n//\n// Interpose processing (-Xlinker -interposable).\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/SwiftInterpose.swift#11 $\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n\nextension SwiftInjection {\n\n /// \"Interpose\" all function definitions in a dylib onto the main executable\n public class func interpose(functionsIn dylib: String) -> [UnsafePointer] {\n var symbols = [UnsafePointer]()\n\n #if false // DLKit based interposing\n // ... doesn't play well with tracing.\n var replacements = [UnsafeMutableRawPointer]()\n\n // Find all definitions of Swift functions and ...\n // SwiftUI body properties defined in the new dylib.\n\n for (symbol, value, _) in DLKit.lastImage\n .swiftSymbols(withSuffixes: injectableSuffixes) {\n guard var replacement = value else {\n continue\n }\n let method = symbol.demangled ?? String(cString: symbol)\n if detail {\n log(\"Replacing \\(method)\")\n }\n\n if traceInjection || SwiftTrace.isTracing, let tracer = SwiftTrace\n .trace(name: injectedPrefix+method, original: replacement) {\n replacement = autoBitCast(tracer)\n }\n\n symbols.append(symbol)\n replacements.append(replacement)\n }\n\n // Rebind all references in all images in the app bundle\n // to function symbols defined in the last loaded dylib\n // to the new implementations in the newly loaded dylib.\n DLKit.appImages[symbols] = replacements\n\n #else // Current SwiftTrace based code...\n let main = dlopen(nil, RTLD_NOW)\n var interposes = [dyld_interpose_tuple]()\n\n #if false\n let suffixesToInterpose = SwiftTrace.traceableFunctionSuffixes\n // Oh alright, interpose all property getters..\n .map { $0 == \"Qrvg\" ? \"g\" : $0 }\n // and class/static members\n .flatMap { [$0, $0+\"Z\"] }\n for suffix in suffixesToInterpose {\n findSwiftSymbols(dylib, suffix) { (loadedFunc, symbol, _, _) in\n // interposing was here ...\n }\n }\n #endif\n filterImageSymbols(ST_LAST_IMAGE, .any, SwiftTrace.injectableSymbol) {\n (loadedFunc, symbol, _, _) in\n guard let existing = dlsym(main, symbol) ??\n findSwiftSymbol(searchBundleImages(), symbol, .any),\n existing != loadedFunc/*,\n let current = SwiftTrace.interposed(replacee: existing)*/ else {\n return\n }\n let current = existing\n traceAndReplace(current, replacement: loadedFunc, symname: symbol) {\n (replacement: UnsafeMutableRawPointer) -> String? in\n interposes.append(dyld_interpose_tuple(replacement: replacement,\n replacee: current))\n symbols.append(symbol)\n return nil //\"Interposing\"\n }\n #if ORIGINAL_2_2_0_CODE\n SwiftTrace.interposed[existing] = loadedFunc\n SwiftTrace.interposed[current] = loadedFunc\n #endif\n }\n\n #if !ORIGINAL_2_2_0_CODE\n //// if interposes.count == 0 { return [] }\n var rebindings = SwiftTrace.record(interposes: interposes, symbols: symbols)\n return SwiftTrace.apply(rebindings: &rebindings,\n onInjection: { (header, slide) in\n var info = Dl_info()\n // Need to apply previous interposes\n // to the newly loaded dylib as well.\n var previous = SwiftTrace.initialRebindings\n var already = Set()\n let interposed = NSObject.swiftTraceInterposed.bindMemory(to:\n [UnsafeRawPointer : UnsafeRawPointer].self, capacity: 1)\n for (replacee, _) in interposed.pointee {\n if let replacement = SwiftTrace.interposed(replacee: replacee),\n already.insert(replacement).inserted,\n dladdr(replacee, &info) != 0, let symname = info.dli_sname {\n previous.append(rebinding(name: symname, replacement:\n UnsafeMutableRawPointer(mutating: replacement),\n replaced: nil))\n }\n }\n rebind_symbols_image(UnsafeMutableRawPointer(mutating: header),\n slide, &previous, previous.count)\n })\n #else // ORIGINAL_2_2_0_CODE replaced by fishhook now\n // Using array of new interpose structs\n interposes.withUnsafeBufferPointer { interps in\n var mostRecentlyLoaded = true\n\n // Apply interposes to all images in the app bundle\n // as well as the most recently loaded \"new\" dylib.\n appBundleImages { image, header in\n if mostRecentlyLoaded {\n // Need to apply all previous interposes\n // to the newly loaded dylib as well.\n var previous = Array()\n for (replacee, replacement) in SwiftTrace.interposed {\n previous.append(dyld_interpose_tuple(\n replacement: replacement, replacee: replacee))\n }\n previous.withUnsafeBufferPointer {\n interps in\n dyld_dynamic_interpose(header,\n interps.baseAddress!, interps.count)\n }\n mostRecentlyLoaded = false\n }\n // patch out symbols defined by new dylib.\n dyld_dynamic_interpose(header,\n interps.baseAddress!, interps.count)\n// print(\"Patched \\(String(cString: image))\")\n }\n }\n #endif\n #endif\n }\n\n /// Interpose references to witness tables, meta data and perhps static variables\n /// to those in main bundle to have them not re-initialise again on each injection.\n static func reverseInterposeStaticsAddressors(_ tmpfile: String) {\n var staticsAccessors = [rebinding]()\n var already = Set()\n var symbolSuffixes = [\"Wl\"] // Witness table accessors\n if false && SwiftTrace.deviceInjection {\n symbolSuffixes.append(\"Ma\") // meta data accessors\n }\n if SwiftTrace.preserveStatics {\n symbolSuffixes.append(\"vau\") // static variable \"mutable addressors\"\n }\n for suffix in symbolSuffixes {\n findHiddenSwiftSymbols(searchLastLoaded(), suffix, .any) {\n accessor, symname, _, _ in\n var original = dlsym(SwiftMeta.RTLD_MAIN_ONLY, symname)\n if original == nil {\n original = findSwiftSymbol(searchBundleImages(), symname, .any)\n if original != nil && !already.contains(original!) {\n detail(\"Recovered top level variable with private scope \" +\n describeImagePointer(original!))\n }\n }\n guard original != nil, already.insert(original!).inserted else {\n return\n }\n detail(\"Reverse interposing \\(original!) <- \\(accessor) \" +\n describeImagePointer(original!))\n staticsAccessors.append(rebinding(name: symname,\n replacement: original!, replaced: nil))\n }\n }\n let injectedImage = _dyld_image_count()-1 // last injected\n let interposed = SwiftTrace.apply(\n rebindings: &staticsAccessors, count: staticsAccessors.count,\n header: lastPseudoImage() ?? _dyld_get_image_header(injectedImage),\n slide: lastPseudoImage() != nil ? 0 :\n _dyld_get_image_vmaddr_slide(injectedImage))\n for symname in interposed {\n detail(\"Reverse interposed \"+describeImageSymbol(symname))\n }\n if interposed.count != staticsAccessors.count && injectionDetail {\n let succeeded = Set(interposed)\n for attemped in staticsAccessors.map({ $0.name }) {\n if !succeeded.contains(attemped) {\n log(\"Reverse interposing \\(interposed.count)/\\(staticsAccessors.count) failed for \\(describeImageSymbol(attemped))\")\n }\n }\n }\n }\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/SwiftKeyPath.swift",
"content": "//\n// SwiftKeyPath.swift\n//\n// Created by John Holdsworth on 20/03/2024.\n// Copyright © 2024 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/SwiftKeyPath.swift#34 $\n//\n// Key paths weren't made to be injected as their underlying types can change.\n// This is particularly evident in code that uses \"The Composable Architecture\".\n// This code maintains a cache of previously allocated key paths using a unique\n// identifier of the calling site so they remain invariant over an injection.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n\nprivate struct ViewBodyKeyPaths {\n typealias KeyPathFunc = @convention(c) (UnsafeMutableRawPointer,\n UnsafeRawPointer) -> UnsafeRawPointer\n\n static let keyPathFuncName = \"swift_getKeyPath\"\n static var save_getKeyPath: KeyPathFunc!\n\n static var cache = [String: ViewBodyKeyPaths]()\n static var lastInjectionNumber = SwiftEval().injectionNumber\n static var hasInjected = false\n\n var lastOffset = 0\n var keyPathNumber = 0\n var recycled = false\n var keyPaths = [UnsafeRawPointer]()\n}\n\n@_cdecl(\"hookKeyPaths\")\npublic func hookKeyPaths(original: UnsafeMutableRawPointer,\n replacer: UnsafeMutableRawPointer) {\n print(APP_PREFIX+\"ℹ️ Intercepting keypaths for when their types are injected.\" +\n \" Set an env var INJECTION_NOKEYPATHS in your scheme to prevent this.\")\n ViewBodyKeyPaths.save_getKeyPath = autoBitCast(original)\n var keyPathRebinding = [rebinding(name: strdup(ViewBodyKeyPaths.keyPathFuncName),\n replacement: replacer, replaced: nil)]\n SwiftTrace.initialRebindings += keyPathRebinding\n _ = SwiftTrace.apply(rebindings: &keyPathRebinding)\n}\n\n@_cdecl(\"injection_getKeyPath\")\npublic func injection_getKeyPath(pattern: UnsafeMutableRawPointer,\n arguments: UnsafeRawPointer) -> UnsafeRawPointer {\n if ViewBodyKeyPaths.lastInjectionNumber != SwiftEval.instance.injectionNumber {\n ViewBodyKeyPaths.lastInjectionNumber = SwiftEval.instance.injectionNumber\n for key in ViewBodyKeyPaths.cache.keys {\n ViewBodyKeyPaths.cache[key]?.keyPathNumber = 0\n ViewBodyKeyPaths.cache[key]?.recycled = false\n }\n ViewBodyKeyPaths.hasInjected = true\n }\n var info = Dl_info()\n for caller in Thread.callStackReturnAddresses.dropFirst() {\n guard let caller = caller.pointerValue,\n dladdr(caller, &info) != 0, let symbol = info.dli_sname,\n let callerDecl = SwiftMeta.demangle(symbol: symbol) else {\n continue\n }\n if !callerDecl.hasSuffix(\".body.getter : some\") {\n break\n }\n // identify caller site\n var relevant: [String] = callerDecl[#\"(closure #\\d+ |in \\S+ : some)\"#]\n if relevant.isEmpty {\n relevant = [callerDecl]\n }\n let callerKey = relevant.joined() + \".keyPath#\"\n// print(callerSym, ins)\n var body = ViewBodyKeyPaths.cache[callerKey] ?? ViewBodyKeyPaths()\n // reset keyPath counter ?\n let offset = caller-info.dli_saddr\n if offset <= body.lastOffset {\n body.keyPathNumber = 0\n body.recycled = false\n }\n body.lastOffset = offset\n// print(\">>\", offset, body.keyPathNumber)\n // extract cached keyPath or create\n let keyPath: UnsafeRawPointer\n if body.keyPathNumber < body.keyPaths.count && ViewBodyKeyPaths.hasInjected {\n SwiftInjection.detail(\"Recycling \\(callerKey)\\(body.keyPathNumber)\")\n keyPath = body.keyPaths[body.keyPathNumber]\n body.recycled = true\n } else {\n keyPath = ViewBodyKeyPaths.save_getKeyPath(pattern, arguments)\n if body.keyPaths.count == body.keyPathNumber {\n body.keyPaths.append(keyPath)\n }\n if body.recycled {\n SwiftInjection.log(\"\"\"\n ⚠️ New key path expression introduced over injection. \\\n This will likely fail and you'll have to restart your \\\n application.\n \"\"\")\n }\n }\n body.keyPathNumber += 1\n ViewBodyKeyPaths.cache[callerKey] = body\n _ = Unmanaged.fromOpaque(keyPath).retain()\n return keyPath\n }\n return ViewBodyKeyPaths.save_getKeyPath(pattern, arguments)\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/SwiftSweeper.swift",
"content": "//\n// SwiftSweeper.swift\n//\n// Created by John Holdsworth on 15/04/2021.\n//\n// The implementation of the memeory sweep to search for\n// instance of classes that have been injected in order\n// to be able to send them the @objc injected message.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/SwiftSweeper.swift#23 $\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n\n#if os(macOS)\nimport Cocoa\ntypealias OSApplication = NSApplication\n#elseif !os(watchOS)\nimport UIKit\ntypealias OSApplication = UIApplication\n#endif\n\n@objc public protocol SwiftInjected {\n @objc optional func injected()\n}\n\nextension SwiftInjection {\n\n static let debugSweep = getenv(INJECTION_SWEEP_DETAIL) != nil\n static let sweepExclusions = { () -> NSRegularExpression? in\n if let exclusions = getenv(INJECTION_SWEEP_EXCLUDE) {\n let pattern = String(cString: exclusions)\n do {\n let filter = try NSRegularExpression(pattern: pattern, options: [])\n print(APP_PREFIX+\"⚠️ Excluding types matching '\\(pattern)' from sweep\")\n return filter\n } catch {\n print(APP_PREFIX+\"⚠️ Invalid sweep filter pattern \\(error): \\(pattern)\")\n }\n }\n return nil\n }()\n\n static var sweepWarned = false\n\n public class func performSweep(oldClasses: [AnyClass], _ tmpfile: String,\n _ injectedGenerics: Set) {\n var injectedClasses = [AnyClass]()\n for cls in oldClasses {\n if class_getInstanceMethod(cls, injectedSEL) != nil {\n injectedClasses.append(cls)\n if !sweepWarned {\n log(\"\"\"\n As class \\(cls) has an @objc injected() \\\n method, \\(APP_NAME) will perform a \"sweep\" of live \\\n instances to determine which objects to message. \\\n If this fails, subscribe to the notification \\\n \"\\(INJECTION_BUNDLE_NOTIFICATION)\" instead.\n \\(APP_PREFIX)(note: notification may not arrive on the main thread)\n \"\"\")\n sweepWarned = true\n }\n let kvoName = \"NSKVONotifying_\" + NSStringFromClass(cls)\n if let kvoCls = NSClassFromString(kvoName) {\n injectedClasses.append(kvoCls)\n }\n }\n }\n\n // implement -injected() method using sweep of objects in application\n if !injectedClasses.isEmpty || !injectedGenerics.isEmpty {\n log(\"Starting sweep \\(injectedClasses), \\(injectedGenerics)...\")\n #if !os(watchOS)\n let app = OSApplication.shared\n let seeds: [Any] = [app.delegate as Any] + app.windows\n #else\n let seeds = [Any]()\n #endif\n var patched = Set()\n SwiftSweeper(instanceTask: {\n (instance: AnyObject) in\n if let instanceClass = object_getClass(instance),\n injectedClasses.contains(where: { $0 == instanceClass }) ||\n !injectedGenerics.isEmpty &&\n patchGenerics(oldClass: instanceClass, tmpfile: tmpfile,\n injectedGenerics: injectedGenerics, patched: &patched) {\n let proto = unsafeBitCast(instance, to: SwiftInjected.self)\n if SwiftEval.sharedInstance().vaccineEnabled {\n performVaccineInjection(instance)\n proto.injected?()\n return\n }\n\n proto.injected?()\n\n #if os(iOS) || os(tvOS)\n if let vc = instance as? UIViewController {\n flash(vc: vc)\n }\n #endif\n }\n }).sweepValue(seeds)\n }\n }\n\n}\n\nclass SwiftSweeper {\n\n static var current: SwiftSweeper?\n\n let instanceTask: (AnyObject) -> Void\n var seen = [UnsafeRawPointer: Bool]()\n\n init(instanceTask: @escaping (AnyObject) -> Void) {\n self.instanceTask = instanceTask\n SwiftSweeper.current = self\n }\n\n func sweepValue(_ value: Any, _ containsType: Bool = false) {\n /// Skip values that cannot be cast into `AnyObject` because they end up being `nil`\n /// Fixes a potential crash that the value is not accessible during injection.\n// print(value)\n guard !containsType && value as? AnyObject != nil else { return }\n\n let mirror = Mirror(reflecting: value)\n if var style = mirror.displayStyle {\n if _typeName(mirror.subjectType).hasPrefix(\"Swift.ImplicitlyUnwrappedOptional<\") {\n style = .optional\n }\n switch style {\n case .set, .collection:\n let containsType = _typeName(type(of: value)).contains(\".Type\")\n if SwiftInjection.debugSweep {\n print(\"Sweeping collection:\", _typeName(type(of: value)))\n }\n for (_, child) in mirror.children {\n sweepValue(child, containsType)\n }\n return\n case .dictionary:\n for (_, child) in mirror.children {\n for (_, element) in Mirror(reflecting: child).children {\n sweepValue(element)\n }\n }\n return\n case .class:\n sweepInstance(value as AnyObject)\n return\n case .optional, .enum:\n if let evals = mirror.children.first?.value {\n sweepValue(evals)\n }\n case .tuple, .struct:\n sweepMembers(value)\n @unknown default:\n break\n }\n }\n }\n\n func sweepInstance(_ instance: AnyObject) {\n let reference = unsafeBitCast(instance, to: UnsafeRawPointer.self)\n if seen[reference] == nil {\n seen[reference] = true\n if let filter = SwiftInjection.sweepExclusions {\n let typeName = _typeName(type(of: instance))\n if filter.firstMatch(in: typeName,\n range: NSMakeRange(0, typeName.utf16.count)) != nil {\n return\n }\n }\n\n if SwiftInjection.debugSweep {\n print(\"Sweeping instance \\(reference) of class \\(type(of: instance))\")\n }\n\n sweepMembers(instance)\n instance.legacySwiftSweep?()\n\n instanceTask(instance)\n }\n }\n\n func sweepMembers(_ instance: Any) {\n var mirror: Mirror? = Mirror(reflecting: instance)\n while mirror != nil {\n for (name, value) in mirror!.children\n where name?.hasSuffix(\"Type\") != true {\n sweepValue(value)\n }\n mirror = mirror!.superclassMirror\n }\n }\n}\n\nextension NSObject {\n @objc func legacySwiftSweep() {\n var icnt: UInt32 = 0, cls: AnyClass? = object_getClass(self)\n while cls != nil && cls != NSObject.self && cls != NSURL.self {\n let className = NSStringFromClass(cls!)\n if className.hasPrefix(\"_\") || className.hasPrefix(\"WK\") ||\n className.hasPrefix(\"NS\") && className != \"NSWindow\" {\n return\n }\n if let ivars = class_copyIvarList(cls, &icnt) {\n let object = UInt8(ascii: \"@\")\n for i in 0 ..< Int(icnt) {\n if /*let name = ivar_getName(ivars[i])\n .flatMap({ String(cString: $0)}),\n sweepExclusions?.firstMatch(in: name,\n range: NSMakeRange(0, name.utf16.count)) == nil,*/\n let type = ivar_getTypeEncoding(ivars[i]), type[0] == object {\n (unsafeBitCast(self, to: UnsafePointer.self) + ivar_getOffset(ivars[i]))\n .withMemoryRebound(to: AnyObject?.self, capacity: 1) {\n// print(\"\\($0.pointee) \\(self) \\(name): \\(String(cString: type))\")\n if let obj = $0.pointee {\n SwiftSweeper.current?.sweepInstance(obj)\n }\n }\n }\n }\n free(ivars)\n }\n cls = class_getSuperclass(cls)\n }\n }\n}\n\nextension NSSet {\n @objc override func legacySwiftSweep() {\n self.forEach { SwiftSweeper.current?.sweepInstance($0 as AnyObject) }\n }\n}\n\nextension NSArray {\n @objc override func legacySwiftSweep() {\n self.forEach { SwiftSweeper.current?.sweepInstance($0 as AnyObject) }\n }\n}\n\nextension NSDictionary {\n @objc override func legacySwiftSweep() {\n self.allValues.forEach { SwiftSweeper.current?.sweepInstance($0 as AnyObject) }\n }\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/UnhidingEval.swift",
"content": "//\n// UnhidingEval.swift\n//\n// Created by John Holdsworth on 13/04/2021.\n//\n// $Id: //depot/HotReloading/Sources/HotReloading/UnhidingEval.swift#27 $\n//\n// Retro-fit Unhide into InjectionIII\n//\n// Unhiding is a work-around for swift giving \"hidden\" visibility\n// to default argument generators which are called when code uses\n// a default argument. \"Hidden\" visibility is somewhere between a\n// public and private declaration where the symbol doesn't become\n// part of the Swift ABI but is nevertheless required at call sites.\n// This causes problems for injection as \"hidden\" symbols are not\n// available outside the framework or executable that defines them.\n// So, a dynamically loading version of a source file that uses a\n// default argument cannot load due to not seeing the symbol.\n//\n// This file calls a piece of C++ in Unhide.mm which scans all the object\n// files of a project looking for symbols for default argument generators\n// that are hidden and makes them public by clearing the N_PEXT flag on\n// the symbol type. Ideally this would happen between compiling and linking\n// But as it is not possible to add a build phase between compiling and\n// linking you have to build again for the object file to be linked into\n// the app executable or framework. This isn't ideal but is about as\n// good as it gets, resolving the injection of files that use default\n// arguments with the minimum disruption to the build process. This\n// file inserts this process when injection is used to keep the files\n// declaring the defaut argument patched sometimes giving an error that\n// asks the user to run the app again and retry.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\nimport Foundation\n#if SWIFT_PACKAGE\nimport SwiftRegex\n#endif\n\n@objc\npublic class UnhidingEval: SwiftEval {\n\n @objc public override class func sharedInstance() -> SwiftEval {\n SwiftEval.instance = UnhidingEval()\n return SwiftEval.instance\n }\n\n static let unhideQueue = DispatchQueue(label: \"unhide\")\n\n static var lastProcessed = [URL: time_t]()\n\n var unhidden = false\n var buildDir: URL?\n\n public override func determineEnvironment(classNameOrFile: String) throws -> (URL, URL) {\n let (project, logs) =\n try super.determineEnvironment(classNameOrFile: classNameOrFile)\n buildDir = logs.deletingLastPathComponent()\n .deletingLastPathComponent().appendingPathComponent(\"Build\")\n if legacyUnhide {\n startUnhide()\n }\n return (project, logs)\n }\n\n override func startUnhide() {\n if !unhidden, let buildDir = buildDir {\n unhidden = true\n Self.unhideQueue.async {\n if let enumerator = FileManager.default\n .enumerator(atPath: buildDir.path),\n let log = fopen(\"/tmp/unhide.log\", \"w\") {\n // linkFileLists contain the list of object files.\n var linkFileLists = [String](), frameworks = [String]()\n for path in enumerator.compactMap({ $0 as? String }) {\n if path.hasSuffix(\".LinkFileList\") {\n linkFileLists.append(path)\n } else if path.hasSuffix(\".framework\") {\n frameworks.append(path)\n }\n }\n // linkFileLists sorted to process packages\n // first due to Edge case in Fruta example.\n let since = Self.lastProcessed[buildDir] ?? 0\n for path in linkFileLists.sorted(by: {\n ($0.hasSuffix(\".o.LinkFileList\") ? 0 : 1) <\n ($1.hasSuffix(\".o.LinkFileList\") ? 0 : 1) }) {\n let fileURL = buildDir\n .appendingPathComponent(path)\n let exported = unhide_symbols(fileURL\n .deletingPathExtension().deletingPathExtension()\n .lastPathComponent, fileURL.path, log, since)\n if exported != 0 {\n let s = exported == 1 ? \"\" : \"s\"\n print(\"\\(APP_PREFIX)Exported \\(exported) default argument\\(s) in \\(fileURL.lastPathComponent)\")\n }\n }\n\n #if false // never implemented\n for framework in frameworks {\n let fileURL = buildDir\n .appendingPathComponent(framework)\n let frameworkName = fileURL\n .deletingPathExtension().lastPathComponent\n let exported = unhide_framework(fileURL\n .appendingPathComponent(frameworkName).path, log)\n if exported != 0 {\n let s = exported == 1 ? \"\" : \"s\"\n print(\"\\(APP_PREFIX)Exported \\(exported) symbol\\(s) in framework \\(frameworkName)\")\n }\n }\n #endif\n\n Self.lastProcessed[buildDir] = time(nil)\n unhide_reset()\n fclose(log)\n }\n }\n }\n }\n\n // This was required for Xcode13's new \"optimisation\" to compile\n // more than one primary file in a single compiler invocation.\n override func xcode13Fix(sourceFile: String,\n compileCommand: inout String) -> String {\n let sourceName = URL(fileURLWithPath: sourceFile)\n .deletingPathExtension().lastPathComponent.escaping().lowercased()\n let hasFileList = compileCommand.contains(\" -filelist \")\n var nPrimaries = 0\n // ensure there is only ever one -primary-file argument and object file\n // avoids shuffling of object files due to how the compiler is coded\n compileCommand[#\" -primary-file (\\#(Self.filePathRegex+Self.fileNameRegex))\"#] = {\n (groups: [String], stop) -> String in\n// debug(\"PF: \\(sourceName) \\(groups)\")\n nPrimaries += 1\n return groups[2].lowercased() == sourceName ||\n groups[3].lowercased() == sourceName ?\n groups[0] : hasFileList ? \"\" : \" \"+groups[1]\n }\n// // Xcode 13 can have multiple primary files but implements default\n// // arguments in a way that no longer requires they be \"unhidden\".\n// if nPrimaries < 2 {\n// startUnhide()\n// }\n // The number of these options must match the number of -primary-file arguments\n // which has just been changed to only ever be one so, strip them out\n let toRemove = #\" -(serialize-diagnostics|emit-(module(-doc|-source-info)?|(reference-)?dependencies|const-values)|index-unit-output)-path \"#\n compileCommand = compileCommand\n .replacingOccurrences(of: toRemove + Self.argumentRegex,\n with: \"\", options: .regularExpression)\n debug(\"Uniqued command:\", compileCommand)\n // Replace path(s) of all object files to a single one\n return super.xcode13Fix(sourceFile: sourceFile,\n compileCommand: &compileCommand)\n }\n\n /// Per-object file version of unhiding on injection to export some symbols\n /// - Parameters:\n /// - executable: Path to app executable to extract module name\n /// - objcClassRefs: Array to accumulate class referrences\n /// - descriptorRefs: Array to accumulate \"l.got\" references to \"fixup\"\n override func createUnhider(executable: String, _ objcClassRefs: NSMutableArray,\n _ descriptorRefs: NSMutableArray) {\n let appModule = URL(fileURLWithPath: executable)\n .lastPathComponent.replacingOccurrences(of: \" \", with: \"_\")\n let appPrefix = \"$s\\(appModule.count)\\(appModule)\"\n objectUnhider = { object_file in\n let logfile = \"/tmp/unhide_object.log\"\n if let log = fopen(logfile, \"w\") {\n setbuf(log, nil)\n objcClassRefs.removeAllObjects()\n descriptorRefs.removeAllObjects()\n unhide_object(object_file, appPrefix, log,\n objcClassRefs, descriptorRefs)\n// self.log(\"Unhidden: \\(object_file) -- \\(appPrefix) -- \\(self.objcClassRefs)\")\n } else {\n// self.log(\"Could not log to \\(logfile)\")\n }\n }\n }\n\n // Non-essential functionality moved here...\n @objc public func rebuild(storyboard: String) throws {\n let (_, logsDir) = try determineEnvironment(classNameOrFile: storyboard)\n\n injectionNumber += 1\n\n // messy but fast\n guard shell(command: \"\"\"\n # search through build logs, most recent first\n cd \"\\(logsDir.path.escaping(\"$\"))\" &&\n for log in `ls -t *.xcactivitylog`; do\n #echo \"Scanning $log\"\n /usr/bin/env perl <(cat <<'PERL'\n use English;\n use strict;\n\n # line separator in Xcode logs\n $INPUT_RECORD_SEPARATOR = \"\\\\r\";\n\n # format is gzip\n open GUNZIP, \"/usr/bin/gunzip <\\\\\"$ARGV[0]\\\\\" 2>/dev/null |\" or die;\n\n # grep the log until to find codesigning for product path\n my $realPath;\n while (defined (my $line = )) {\n if ($line =~ /^\\\\s*cd /) {\n $realPath = $line;\n }\n elsif (my ($product) = $line =~ m@/usr/bin/ibtool.*? --link (([^\\\\ ]+\\\\\\\\ )*\\\\S+\\\\.app)@o) {\n print $product;\n exit 0;\n }\n }\n\n # class/file not found\n exit 1;\n PERL\n ) \"$log\" >\"\\(tmpfile).sh\" && exit 0\n done\n exit 1;\n \"\"\") else {\n throw scriptError(\"Locating storyboard compile\")\n }\n\n guard let resources = try? String(contentsOfFile: \"\\(tmpfile).sh\")\n .trimmingCharacters(in: .whitespaces) else {\n throw scriptError(\"Locating product\")\n }\n\n guard shell(command: \"\"\"\n (cd \"\\(resources.unescape().escaping(\"$\"))\" && for i in 1 2 3 4 5; \\\n do if (find . -name '*.nib' -a -newer \"\\(storyboard)\" | \\\n grep .nib >/dev/null); then break; fi; sleep 1; done; \\\n while (ps auxww | grep -v grep | grep \"/ibtool \" >/dev/null); do sleep 1; done; \\\n for i in `find . -name '*.nib'`; do cp -rf \"$i\" \"\\(\n Bundle.main.bundlePath)/$i\"; done >\"\\(logfile)\" 2>&1)\n \"\"\") else {\n throw scriptError(\"Re-compilation\")\n }\n\n _ = evalError(\"Copied \\(storyboard)\")\n }\n\n // Assorted bazel code moved out of SwiftEval.swift\n override func bazelLink(in projectRoot: String, since sourceFile: String,\n compileCommand: String) throws -> String {\n guard var objects = bazelFiles(under: projectRoot, where: \"\"\"\n -newer \"\\(sourceFile)\" -a -name '*.o' | \\\n egrep '(_swift_incremental|_objs)/' | grep -v /external/\n \"\"\") else {\n throw evalError(\"Finding Objects failed. Did you actually make a change to \\(sourceFile) and does it compile? InjectionIII does not support whole module optimization. (check logfile: \\(logfile))\")\n }\n\n debug(bazelLight, projectRoot, objects)\n // precendence to incrementally compiled\n let incremental = objects.filter({ $0.contains(\"_swift_incremental\") })\n if incremental.count > 0 {\n objects = incremental\n }\n\n #if true\n // With WMO, which modifies all object files\n // we need a way to filter them down to that\n // of the source file and its related module\n // library to provide shared \"hidden\" symbols.\n // We use the related Swift \"output_file_map\"\n // for the module name to include its library.\n if objects.count > 1 {\n let objectSet = Set(objects)\n if let maps = bazelFiles(under: projectRoot,\n where: \"-name '*output_file_map*.json'\") {\n let relativePath = sourceFile .replacingOccurrences(\n of: projectRoot+\"/\", with: \"\")\n for map in maps {\n if let data = try? Data(contentsOf: URL(\n fileURLWithPath: projectRoot)\n .appendingPathComponent(map)),\n let json = try? JSONSerialization.jsonObject(\n with: data, options: []) as? [String: Any],\n let info = json[relativePath] as? [String: String] {\n if let object = info[\"object\"],\n objectSet.contains(object) {\n objects = [object]\n if let module: String =\n map[#\"(\\w+)\\.output_file_map\"#] {\n for lib in bazelFiles(under: projectRoot,\n where: \"-name 'lib\\(module).a'\") ?? [] {\n moduleLibraries.insert(lib)\n }\n }\n break\n }\n }\n }\n } else {\n _ = evalError(\"Error reading maps\")\n }\n }\n #endif\n\n objects += moduleLibraries\n debug(objects)\n\n try link(dylib: \"\\(tmpfile).dylib\", compileCommand: compileCommand,\n contents: objects.map({ \"\\\"\\($0)\\\"\"}).joined(separator: \" \"),\n cd: projectRoot)\n return tmpfile\n }\n\n func bazelFiles(under projectRoot: String, where clause: String,\n ext: String = \"files\") -> [String]? {\n let list = \"\\(tmpfile).\\(ext)\"\n if shell(command: \"\"\"\n cd \"\\(projectRoot)\" && \\\n find bazel-out/* \\(clause) >\"\\(list)\" 2>>\\\"\\(logfile)\\\"\n \"\"\"), let files = (try? String(contentsOfFile: list))?\n .components(separatedBy: \"\\n\").dropLast() {\n return Array(files)\n }\n return nil\n }\n\n override func bazelLight(projectRoot: String, recompile sourceFile: String) throws -> String? {\n let relativePath = sourceFile.replacingOccurrences(of:\n projectRoot+\"/\", with: \"\")\n let bazelRulesSwift = projectRoot +\n \"/bazel-out/../external/build_bazel_rules_swift\"\n let paramsScanner = tmpDir + \"/bazel.pl\"\n debug(projectRoot, relativePath, bazelRulesSwift, paramsScanner)\n\n if !sourceFile.hasSuffix(\".swift\") {\n throw evalError(\"Only Swift sources can be standalone injected with bazel\")\n }\n\n try #\"\"\"\n use JSON::PP;\n use English;\n use strict;\n\n my ($params, $relative) = @ARGV;\n my $args = join('', (IO::File->new( \"< $params\" )\n or die \"Could not open response '$params'\")->getlines());\n my ($filemap) = $args =~ /\"-output-file-map\"\\n\"([^\"]+)\"/;\n my $file_handle = IO::File->new( \"< $filemap\" )\n or die \"Could not open filemap '$filemap'\";\n my $json_text = join'', $file_handle->getlines();\n my $json_map = decode_json( $json_text, { utf8 => 1 } );\n\n if (my $info = $json_map->{$relative}) {\n $args =~ s/\"-(emit-(module|objc-header)-path\"\\n\"[^\"]+)\"\\n//g;\n my $paramscopy = \"$params.copy\";\n my $paramsfile = IO::File->new(\"> $paramscopy\");\n binmode $paramsfile, ':utf8';\n $paramsfile->print($args);\n $paramsfile->close();\n print \"$paramscopy\\n$info->{object}\\n\";\n exit 0;\n }\n # source file not found\n exit 1;\n \"\"\"#.write(toFile: paramsScanner,\n atomically: false, encoding: .utf8)\n\n let errfile = \"\\(tmpfile).err\"\n guard shell(command: \"\"\"\n # search through bazel args, most recent first\n cd \"\\(bazelRulesSwift)\" 2>\"\\(errfile)\" &&\n grep module_name_ tools/worker/swift_runner.h >/dev/null 2>>\"\\(errfile)\" ||\n (git apply -v <<'BAZEL_PATCH' 2>>\"\\(errfile)\" && echo \"⚠️ bazel patched, restart app\" >>\"\\(errfile)\" && exit 1) &&\n diff --git a/tools/worker/swift_runner.cc b/tools/worker/swift_runner.cc\n index 535dad0..19e1a6d 100644\n --- a/tools/worker/swift_runner.cc\n +++ b/tools/worker/swift_runner.cc\n @@ -369,6 +369,11 @@ std::vector SwiftRunner::ParseArguments(Iterator itr) {\n arg = *it;\n output_file_map_path_ = arg;\n out_args.push_back(arg);\n + } else if (arg == \"-module-name\") {\n + ++it;\n + arg = *it;\n + module_name_ = arg;\n + out_args.push_back(arg);\n } else if (arg == \"-index-store-path\") {\n ++it;\n arg = *it;\n @@ -410,12 +415,28 @@ std::vector SwiftRunner::ProcessArguments(\n ++it;\n }\n\n + auto copy = \"/tmp/bazel_\"+module_name_+\".params\";\n + unlink(copy.c_str());\n if (force_response_file_) {\n // Write the processed args to the response file, and push the path to that\n // file (preceded by '@') onto the arg list being returned.\n auto new_file = WriteResponseFile(response_file_args);\n new_args.push_back(\"@\" + new_file->GetPath());\n +\n + // patch to retain swiftc arguments file\n + link(new_file->GetPath().c_str(), copy.c_str());\n temp_files_.push_back(std::move(new_file));\n + } else if (FILE *fp = fopen(\"/tmp/forced_params.txt\", \"w+\")) {\n + // alternate patch to capture arguments file\n + for (auto &a : args_destination) {\n + const char *carg = a.c_str();\n + fprintf(fp, \"%s\\\\n\", carg);\n + if (carg[0] != '@')\n + continue;\n + link(carg+1, copy.c_str());\n + fprintf(fp, \"Linked %s to %s\\\\n\", copy.c_str(), carg+1);\n + }\n + fclose(fp);\n }\n\n return new_args;\n diff --git a/tools/worker/swift_runner.h b/tools/worker/swift_runner.h\n index 952c593..35cf055 100644\n --- a/tools/worker/swift_runner.h\n +++ b/tools/worker/swift_runner.h\n @@ -153,6 +153,9 @@ class SwiftRunner {\n // The index store path argument passed to the runner\n std::string index_store_path_;\n\n + // Swift modue name from -module-name\n + std::string module_name_ = \"Unknown\";\n +\n // The path of the global index store when using\n // swift.use_global_index_store. When set, this is passed to `swiftc` as the\n // `-index-store-path`. After running `swiftc` `index-import` copies relevant\n BAZEL_PATCH\n\n cd \"\\(projectRoot)\" 2>>\"\\(errfile)\" &&\n for params in `ls -t /tmp/bazel_*.params 2>>\"\\(errfile)\"`; do\n #echo \"Scanning $params\"\n /usr/bin/env perl \"\\(paramsScanner)\" \"$params\" \"\\(relativePath)\" \\\n >\"\\(tmpfile).sh\" 2>>\"\\(errfile)\" && exit 0\n done\n exit 1;\n \"\"\"), let returned = (try? String(contentsOfFile: \"\\(tmpfile).sh\"))?\n .components(separatedBy: \"\\n\") else {\n if let log = try? String(contentsOfFile: errfile), log != \"\" {\n throw evalError(log.contains(\"ls: /tmp/bazel_*.params\") ? \"\"\"\n \\(log)Response files not available (see: \\(cmdfile))\n Edit and save a swift source file and restart app.\n \"\"\" : \"\"\"\n Locating response file failed (see: \\(cmdfile))\n \\(log)\n \"\"\")\n }\n return nil\n }\n\n let params = returned[0]\n _ = evalError(\"Compiling using parameters from \\(params)\")\n\n guard shell(command: \"\"\"\n cd \"\\(projectRoot)\" && \\\n chmod +w `find bazel-out/* -name '*.o'`; \\\n xcrun swiftc @\\(params) >\\\"\\(logfile)\\\" 2>&1\n \"\"\") || shell(command: \"\"\"\n cd `readlink \"\\(projectRoot)/bazel-out\"`/.. && \\\n chmod +w `find bazel-out/* -name '*.o'`; \\\n xcrun swiftc @\\(params) >>\\\"\\(logfile)\\\" 2>&1\n \"\"\"),\n let compileCommand = try? String(contentsOfFile: params) else {\n throw scriptError(\"Recompiling\")\n }\n\n return try bazelLink(in: projectRoot, since: sourceFile,\n compileCommand: compileCommand)\n }\n\n}\n#endif\n"
},
{
"path": "Sources/HotReloading/Vaccine.swift",
"content": "#if (DEBUG || !SWIFT_PACKAGE) && !os(watchOS)\n#if os(macOS)\nimport Cocoa\ntypealias View = NSView\ntypealias ViewController = NSViewController\ntypealias ScrollView = NSScrollView\n#else\nimport UIKit\ntypealias View = UIView\ntypealias ViewController = UIViewController\ntypealias ScrollView = UIScrollView\n\nfileprivate extension ViewController {\n func viewWillAppear() { self.viewWillAppear(false) }\n func viewDidAppear() { self.viewDidAppear(false) }\n}\n#endif\n\nextension View {\n func subviewsRecursive() -> [View] {\n return subviews + subviews.flatMap { $0.subviewsRecursive() }\n }\n}\n\nclass Vaccine {\n func performInjection(on object: AnyObject) {\n switch object {\n case let viewController as ViewController:\n let snapshotView: View? = createSnapshotViewIfNeeded(for: viewController)\n if viewController.nibName == nil {\n CATransaction.begin()\n CATransaction.setAnimationDuration(1.0)\n CATransaction.setAnimationTimingFunction(CAMediaTimingFunction(name: CAMediaTimingFunctionName.easeInEaseOut))\n defer { CATransaction.commit() }\n }\n\n let oldScrollViews = indexScrollViews(on: viewController)\n\n #if os(macOS)\n reload(viewController.parent ?? viewController)\n #else\n // Opt-out from performing Vaccine reloads on parent\n // if the parent is either a navigation controller or\n // a tab bar controller.\n if let parentViewController = viewController.parent {\n if parentViewController is UINavigationController {\n reload(viewController)\n } else if parentViewController is UITabBarController {\n reload(viewController)\n } else {\n reload(parentViewController)\n }\n } else {\n reload(viewController)\n }\n #endif\n\n syncOldScrollViews(oldScrollViews, with: indexScrollViews(on: viewController))\n cleanSnapshotViewIfNeeded(snapshotView, viewController: viewController)\n case let view as View:\n reload(view)\n default:\n break\n }\n }\n\n private func reload(_ viewController: ViewController) {\n viewController.view.subviews.forEach { $0.removeFromSuperview() }\n clean(view: viewController.view)\n viewController.loadView()\n viewController.viewDidLoad()\n viewController.viewWillAppear()\n viewController.viewDidAppear()\n refreshSubviews(on: viewController.view)\n }\n\n private func reload(_ view: View) {\n let selector = _Selector(\"loadView\")\n guard view.responds(to: selector) == true else { return }\n\n #if os(macOS)\n view.animator().perform(selector)\n #else\n UIView.animate(withDuration: 0.3, delay: 0.0, options: [.allowAnimatedContent,\n .beginFromCurrentState,\n .layoutSubviews], animations: {\n view.perform(selector)\n }, completion: nil)\n #endif\n }\n\n private func createSnapshotViewIfNeeded(for viewController: ViewController) -> View? {\n if let snapshotView = createSnapshot(from: viewController.view), viewController.nibName == nil {\n #if os(macOS)\n viewController.view.window?.contentView?.addSubview(snapshotView)\n #else\n let maskView = UIView()\n maskView.frame.size = snapshotView.frame.size\n maskView.frame.origin.y = viewController.navigationController?.navigationBar.frame.maxY ?? 0\n maskView.backgroundColor = .white\n snapshotView.mask = maskView\n viewController.view.window?.addSubview(snapshotView)\n #endif\n\n return snapshotView\n\n }\n return nil\n }\n\n private func cleanSnapshotViewIfNeeded(_ snapshotView: View?, viewController: ViewController) {\n if let snapshotView = snapshotView, viewController.nibName == nil {\n #if os(macOS)\n NSAnimationContext.runAnimationGroup({ (context) in\n context.allowsImplicitAnimation = true\n context.duration = 0.25\n snapshotView.animator().alphaValue = 0.0\n }, completionHandler: {\n snapshotView.removeFromSuperview()\n })\n #else\n UIView.animate(withDuration: 0.25,\n delay: 0.0,\n options: [.allowAnimatedContent,\n .beginFromCurrentState,\n .layoutSubviews],\n animations: {\n snapshotView.alpha = 0.0\n }) { _ in\n snapshotView.removeFromSuperview()\n }\n #endif\n }\n }\n\n private func clean(view: View) {\n view.subviews.forEach { $0.removeFromSuperview() }\n\n #if os(macOS)\n if let sublayers = view.layer?.sublayers {\n sublayers.forEach { $0.removeFromSuperlayer() }\n }\n #else\n if let sublayers = view.layer.sublayers {\n sublayers.forEach { $0.removeFromSuperlayer() }\n }\n #endif\n }\n\n private func refreshSubviews(on view: View) {\n #if os(macOS)\n view.subviewsRecursive().forEach { view in\n (view as? NSTableView)?.reloadData()\n (view as? NSCollectionView)?.reloadData()\n view.needsLayout = true\n view.layout()\n view.needsDisplay = true\n view.display()\n }\n #else\n view.subviewsRecursive().forEach { view in\n (view as? UITableView)?.reloadData()\n (view as? UICollectionView)?.reloadData()\n view.setNeedsLayout()\n view.layoutIfNeeded()\n view.setNeedsDisplay()\n }\n #endif\n }\n\n private func indexScrollViews(on viewController: ViewController) -> [ScrollView] {\n var scrollViews = [ScrollView]()\n\n for case let scrollView as ScrollView in viewController.view.subviews {\n scrollViews.append(scrollView)\n }\n\n if let parentViewController = viewController.parent {\n for case let scrollView as ScrollView in parentViewController.view.subviews {\n scrollViews.append(scrollView)\n }\n }\n\n for childViewController in viewController.children {\n for case let scrollView as ScrollView in childViewController.view.subviews {\n scrollViews.append(scrollView)\n }\n }\n\n return scrollViews\n }\n\n private func syncOldScrollViews(_ oldScrollViews: [ScrollView], with newScrollViews: [ScrollView]) {\n for (offset, scrollView) in newScrollViews.enumerated() {\n if offset < oldScrollViews.count {\n let oldScrollView = oldScrollViews[offset]\n if type(of: scrollView) == type(of: oldScrollView) {\n #if os(macOS)\n scrollView.contentView.scroll(to: oldScrollView.documentVisibleRect.origin)\n #else\n scrollView.contentOffset = oldScrollView.contentOffset\n #endif\n }\n }\n }\n }\n\n private func createSnapshot(from view: View) -> View? {\n #if os(macOS)\n let snapshot = NSImageView()\n snapshot.image = view.snapshot\n snapshot.frame.size = view.frame.size\n return snapshot\n #else\n return view.snapshotView(afterScreenUpdates: true)\n #endif\n }\n\n private func _Selector(_ string: String) -> Selector {\n return Selector(string)\n }\n}\n\n#if os(macOS)\nfileprivate extension NSView {\n var snapshot: NSImage {\n guard let bitmapRep = bitmapImageRepForCachingDisplay(in: bounds) else { return NSImage() }\n cacheDisplay(in: bounds, to: bitmapRep)\n let image = NSImage()\n image.addRepresentation(bitmapRep)\n bitmapRep.size = bounds.size.doubleScale()\n return image\n }\n}\nfileprivate extension CGSize {\n func doubleScale() -> CGSize {\n return CGSize(width: width * 2, height: height * 2)\n }\n}\n#endif\n#endif\n"
},
{
"path": "Sources/HotReloadingGuts/ClientBoot.mm",
"content": "//\n// ClientBoot.mm\n// InjectionIII\n//\n// Created by John Holdsworth on 02/24/2021.\n// Copyright © 2021 John Holdsworth. All rights reserved.\n//\n// $Id: //depot/HotReloading/Sources/HotReloadingGuts/ClientBoot.mm#131 $\n//\n// Initiate connection to server side of InjectionIII/HotReloading.\n//\n\n#if DEBUG || !SWIFT_PACKAGE\n#import \"InjectionClient.h\"\n#import \n#import \n#import \"SimpleSocket.h\"\n#import \n\n#ifndef INJECTION_III_APP\nNSString *INJECTION_KEY = @__FILE__;\n#endif\n\n#if defined(DEBUG) || defined(INJECTION_III_APP)\nstatic SimpleSocket *injectionClient;\nNSString *injectionHost = @\"127.0.0.1\";\nstatic dispatch_once_t onlyOneClient;\n\n@implementation SimpleSocket(Connect)\n\n+ (void)backgroundConnect:(const char *)host {\n dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{\n if (SimpleSocket *client = [[self class] connectTo:[NSString\n stringWithFormat:@\"%s%@\", host, @INJECTION_ADDRESS]])\n dispatch_once(&onlyOneClient, ^{\n injectionHost = [NSString stringWithUTF8String:host];\n [injectionClient = client run];\n });\n });\n}\n\n@end\n\n@interface BundleInjection: NSObject\n@end\n@implementation BundleInjection\n\nextern \"C\" {\n extern void hookKeyPaths(void *original, void *replacement);\n extern const void *swift_getKeyPath(void *, const void *);\n extern const void *injection_getKeyPath(void *, const void *);\n extern void injection_hookGenerics(void *original, void *replacement);\n extern Class swift_allocateGenericClassMetadata(void *, void *, void *);\n extern Class injection_allocateGenericClassMetadata(void *, void *, void *);\n}\n\n+ (void)load {\n // If the custom TEST_HOST used to load XCTestBundle, and this custom TEST_HOST is a normal iOS/macOS/tvOS app,\n // then XCTestCase can instantiate NSWindow / UIWindow, make it key and visible, pause and wait for\n // standard expectation – XCTestExpectation. This untypical flow used for per-screen UI development without need\n // to launch full app. To support this flow we are allowing injection by respecting dedicated environment variable.\n bool shouldUseInTests = getenv(INJECTION_USEINTESTS) != nullptr;\n\n // See: https://forums.developer.apple.com/forums/thread/761439\n bool isPreviewsDetected = getenv(\"XCODE_RUNNING_FOR_PREVIEWS\") != nullptr;\n // See: https://github.com/pointfreeco/swift-issue-reporting/blob/main/Sources/IssueReporting/IsTesting.swift#L29\n bool isTestsDetected = getenv(\"XCTestBundlePath\") ||\n getenv(\"XCTestSessionIdentifier\") ||\n getenv(\"XCTestConfigurationFilePath\");\n if (isPreviewsDetected || (isTestsDetected && !shouldUseInTests))\n return; // inhibit in previews or when running tests, unless explicitly enabled in tests.\n #if !(SWIFT_PACKAGE && TARGET_OS_OSX)\n if (!getenv(INJECTION_NOKEYPATHS) && (getenv(INJECTION_KEYPATHS)\n #if !SWIFT_PACKAGE\n || dlsym(RTLD_DEFAULT, \"$s22ComposableArchitecture6LoggerCN\")\n #endif\n ))\n hookKeyPaths((void *)swift_getKeyPath, (void *)injection_getKeyPath);\n #endif\n #if !SWIFT_PACKAGE\n if (!getenv(INJECTION_NOGENERICS) && !getenv(INJECTION_OF_GENERICS))\n injection_hookGenerics((void *)swift_allocateGenericClassMetadata,\n (void *)injection_allocateGenericClassMetadata);\n #else\n printf(APP_PREFIX\"⚠️ Define env var \" INJECTION_OF_GENERICS\n \" in your scheme to inject generic classes.\\n\");\n #endif\n if (Class clientClass = objc_getClass(\"InjectionClient\"))\n [self performSelectorInBackground:@selector(tryConnect:)\n withObject:clientClass];\n}\n\n+ (void)tryConnect:(Class)clientClass {\n NSString *socketAddr = @INJECTION_ADDRESS;\n __unused const char *buildPhase = APP_PREFIX\"You'll need to be running \"\n \"a recent copy of the InjectionIII.app downloaded from \"\n \"https://github.com/johnno1962/InjectionIII/releases\\n\"\n APP_PREFIX\"And have typed: defaults write com.johnholdsworth.InjectionIII deviceUnlock any\\n\";\n BOOL isVapor = dlsym(RTLD_DEFAULT, VAPOR_SYMBOL) != nullptr;\n#if TARGET_IPHONE_SIMULATOR || TARGET_OS_OSX\n#if 0 && !defined(INJECTION_III_APP)\n BOOL isiOSAppOnMac = false;\n if (@available(iOS 14.0, *)) {\n isiOSAppOnMac = [NSProcessInfo processInfo].isiOSAppOnMac;\n }\n if (!isiOSAppOnMac && !isVapor && !getenv(INJECTION_DAEMON))\n if (Class standalone = objc_getClass(\"StandaloneInjection\")) {\n [[standalone new] run];\n return;\n }\n#endif\n#elif TARGET_OS_IPHONE\n const char *envHost = getenv(INJECTION_HOST);\n if (envHost)\n [clientClass backgroundConnect:envHost];\n #ifdef DEVELOPER_HOST\n [clientClass backgroundConnect:DEVELOPER_HOST];\n if (!isdigit(DEVELOPER_HOST[0]) && !envHost)\n printf(APP_PREFIX\"Sending broadcast packet to connect to your development host %s.\\n\"\n APP_PREFIX\"If this fails, hardcode your Mac's IP address in HotReloading/Package.swift\\n\"\n \" or add an environment variable \" INJECTION_HOST\n \" with this value.\\n%s\", DEVELOPER_HOST, buildPhase);\n #endif\n if (!(@available(iOS 14.0, *) && [NSProcessInfo processInfo].isiOSAppOnMac))\n injectionHost = [clientClass\n getMulticastService:HOTRELOADING_MULTICAST port:HOTRELOADING_PORT\n message:APP_PREFIX\"Connecting to %s (%s)...\\n\"];\n socketAddr = [injectionHost stringByAppendingString:@HOTRELOADING_PORT];\n if (injectionClient)\n return;\n#endif\n for (int retry=0, retrys=1; retry\n#include \n#include \n#include \n#include \n\n#if 0\n#define SLog NSLog\n#else\n#define SLog while(0) NSLog\n#endif\n\n#define MAX_PACKET 16384\n\ntypedef union {\n struct {\n __uint8_t sa_len; /* total length */\n sa_family_t sa_family; /* [XSI] address family */\n };\n struct sockaddr_storage any;\n struct sockaddr_in ip4;\n struct sockaddr addr;\n} sockaddr_union;\n\n@implementation SimpleSocket\n\n+ (int)error:(NSString *)message {\n NSLog([@\"%@/\" stringByAppendingString:message],\n self, strerror(errno));\n return -1;\n}\n\n+ (void)startServer:(NSString *)address {\n [self performSelectorInBackground:@selector(runServer:) withObject:address];\n}\n\n+ (void)forEachInterface:(void (^)(ifaddrs *ifa, in_addr_t addr, in_addr_t mask))handler {\n ifaddrs *addrs;\n if (getifaddrs(&addrs) < 0) {\n [self error:@\"Could not getifaddrs: %s\"];\n return;\n }\n for (ifaddrs *ifa = addrs; ifa; ifa = ifa->ifa_next)\n if (ifa->ifa_addr->sa_family == AF_INET)\n handler(ifa, ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr,\n ((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr.s_addr);\n freeifaddrs(addrs);\n}\n\n+ (void)runServer:(NSString *)address {\n sockaddr_union serverAddr;\n [self parseV4Address:address into:&serverAddr.any];\n\n int serverSocket = [self newSocket:serverAddr.sa_family];\n if (serverSocket < 0)\n return;\n\n if (bind(serverSocket, &serverAddr.addr, serverAddr.sa_len) < 0)\n [self error:@\"Could not bind service socket: %s\"];\n else if (listen(serverSocket, 5) < 0)\n [self error:@\"Service socket would not listen: %s\"];\n else\n while (TRUE) {\n sockaddr_union clientAddr;\n socklen_t addrLen = sizeof clientAddr;\n\n int clientSocket = accept(serverSocket, &clientAddr.addr, &addrLen);\n if (clientSocket > 0) {\n int yes = 1;\n if (setsockopt(clientSocket, SOL_SOCKET, SO_NOSIGPIPE, &yes, sizeof yes) < 0)\n [self error:@\"Could not set SO_NOSIGPIPE: %s\"];\n @autoreleasepool {\n struct sockaddr_in *v4Addr = &clientAddr.ip4;\n NSLog(@\"Connection from %s:%d\\n\",\n inet_ntoa(v4Addr->sin_addr), ntohs(v4Addr->sin_port));\n SimpleSocket *client = [[self alloc] initSocket:clientSocket];\n client.isLocalClient =\n v4Addr->sin_addr.s_addr == htonl(INADDR_LOOPBACK);\n [self forEachInterface:^(ifaddrs *ifa, in_addr_t addr, in_addr_t mask) {\n if (v4Addr->sin_addr.s_addr == addr)\n client.isLocalClient = TRUE;\n }];\n [client run];\n }\n }\n else\n [NSThread sleepForTimeInterval:.5];\n }\n}\n\n+ (instancetype)connectTo:(NSString *)address {\n sockaddr_union serverAddr;\n [self parseV4Address:address into:&serverAddr.any];\n\n int clientSocket = [self newSocket:serverAddr.sa_family];\n if (clientSocket < 0)\n return nil;\n\n if (connect(clientSocket, &serverAddr.addr, serverAddr.sa_len) < 0) {\n [self error:@\"Could not connect: %s\"];\n return nil;\n }\n\n return [[self alloc] initSocket:clientSocket];\n}\n\n+ (int)newSocket:(sa_family_t)addressFamily {\n int newSocket, yes = 1;\n if ((newSocket = socket(addressFamily, SOCK_STREAM, 0)) < 0)\n [self error:@\"Could not open service socket: %s\"];\n else if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0)\n [self error:@\"Could not set SO_REUSEADDR: %s\"];\n else if (setsockopt(newSocket, SOL_SOCKET, SO_NOSIGPIPE, &yes, sizeof yes) < 0)\n [self error:@\"Could not set SO_NOSIGPIPE: %s\"];\n else if (setsockopt(newSocket, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof yes) < 0)\n [self error:@\"Could not set TCP_NODELAY: %s\"];\n else if (fcntl(newSocket, F_SETFD, FD_CLOEXEC) < 0)\n [self error:@\"Could not set FD_CLOEXEC: %s\"];\n else\n return newSocket;\n return -1;\n}\n\n/**\n * Available formats\n * @\"[:]\"\n * where can be NNN.NNN.NNN.NNN or hostname, empty for localhost or * for all interfaces\n * The default port is 80 or a specific number to bind or an empty string to allocate any port\n */\n+ (BOOL)parseV4Address:(NSString *)address into:(struct sockaddr_storage *)serverAddr {\n NSArray *parts = [address componentsSeparatedByString:@\":\"];\n\n struct sockaddr_in *v4Addr = (struct sockaddr_in *)serverAddr;\n bzero(v4Addr, sizeof *v4Addr);\n\n v4Addr->sin_family = AF_INET;\n v4Addr->sin_len = sizeof *v4Addr;\n v4Addr->sin_port = htons(parts.count > 1 ? parts[1].intValue : 80);\n\n const char *host = parts[0].UTF8String;\n\n if (!host[0])\n v4Addr->sin_addr.s_addr = htonl(INADDR_LOOPBACK);\n else if (host[0] == '*')\n v4Addr->sin_addr.s_addr = htonl(INADDR_ANY);\n else if (isdigit(host[0]))\n v4Addr->sin_addr.s_addr = inet_addr(host);\n else if (struct hostent *hp = gethostbyname2(host, v4Addr->sin_family))\n memcpy(&v4Addr->sin_addr, hp->h_addr, hp->h_length);\n else {\n [self error:[NSString stringWithFormat:@\"Unable to look up host for %@\", address]];\n return FALSE;\n }\n\n return TRUE;\n}\n\n- (instancetype)initSocket:(int)socket {\n if ((self = [super init])) {\n clientSocket = socket;\n }\n return self;\n}\n\n- (void)run {\n [self performSelectorInBackground:@selector(runInBackground) withObject:nil];\n}\n\n- (void)runInBackground {\n [[self class] error:@\"-[SimpleSocket runInBackground] not implemented in subclass\"];\n}\n\ntypedef ssize_t (*io_func)(int, void *, size_t);\n\n- (BOOL)perform:(io_func)io ofBytes:(const void *)buffer\n length:(size_t)length cmd:(SEL)cmd {\n size_t bytes, ptr = 0;\n SLog(@\"#%d %s %lu [%p] %s\", clientSocket, io == read ?\n \"<-\" : \"->\", length, buffer, sel_getName(cmd));\n while (ptr < length && (bytes = io(clientSocket,\n (char *)buffer+ptr, MIN(length-ptr, MAX_PACKET))) > 0)\n ptr += bytes;\n if (ptr < length) {\n NSLog(@\"[%@ %s:%p length:%lu] error: %lu %s\",\n self, sel_getName(cmd), buffer, length, ptr, strerror(errno));\n return FALSE;\n }\n return TRUE;\n}\n\n- (BOOL)readBytes:(void *)buffer length:(size_t)length cmd:(SEL)cmd {\n return [self perform:read ofBytes:buffer length:length cmd:cmd];\n}\n\n- (int)readInt {\n int32_t anint = ~0;\n if (![self readBytes:&anint length:sizeof anint cmd:_cmd])\n return ~0;\n SLog(@\"#%d <- %d\", clientSocket, anint);\n return anint;\n}\n\n- (void *)readPointer {\n void *aptr = (void *)~0;\n if (![self readBytes:&aptr length:sizeof aptr cmd:_cmd])\n return aptr;\n SLog(@\"#%d <- %p\", clientSocket, aptr);\n return aptr;\n}\n\n- (NSData *)readData {\n size_t length = [self readInt];\n void *bytes = malloc(length);\n if (!bytes || ![self readBytes:bytes length:length cmd:_cmd])\n return nil;\n return [NSData dataWithBytesNoCopy:bytes length:length freeWhenDone:YES];\n}\n\n- (NSString *)readString {\n NSString *str = [[NSString alloc] initWithData:[self readData]\n encoding:NSUTF8StringEncoding];\n SLog(@\"#%d <- %d '%@'\", clientSocket, (int)str.length, str);\n return str;\n}\n\n- (BOOL)writeBytes:(const void *)buffer length:(size_t)length cmd:(SEL)cmd {\n return [self perform:(io_func)write ofBytes:buffer length:length cmd:cmd];\n}\n\n- (BOOL)writeInt:(int)length {\n SLog(@\"#%d %d ->\", clientSocket, length);\n return [self writeBytes:&length length:sizeof length cmd:_cmd];\n}\n\n- (BOOL)writePointer:(void *)ptr {\n SLog(@\"#%d %p ->\", clientSocket, ptr);\n return [self writeBytes:&ptr length:sizeof ptr cmd:_cmd];\n}\n\n- (BOOL)writeData:(NSData *)data {\n uint32_t length = (uint32_t)data.length;\n SLog(@\"#%d [%d] ->\", clientSocket, length);\n return [self writeInt:length] &&\n [self writeBytes:data.bytes length:length cmd:_cmd];\n}\n\n- (BOOL)writeString:(NSString *)string {\n NSData *data = [string dataUsingEncoding:NSUTF8StringEncoding];\n SLog(@\"#%d %d '%@' ->\", clientSocket, (int)data.length, string);\n return [self writeData:data];\n}\n\n- (BOOL)writeCommand:(int)command withString:(NSString *)string {\n return [self writeInt:command] &&\n (!string || [self writeString:string]);\n}\n\n- (void)dealloc {\n close(clientSocket);\n}\n\n/// Hash used to differentiate HotReloading users on network.\n/// Derived from path to source file in project's DerivedData.\n+ (int)multicastHash {\n #ifdef INJECTION_III_APP\n const char *key = [[NSBundle bundleForClass:self]\n .infoDictionary[@\"UserHome\"] UTF8String] ?:\n NSHomeDirectory().UTF8String;\n #else\n NSString *file = [NSString stringWithUTF8String:__FILE__];\n const char *key = [file\n stringByReplacingOccurrencesOfString: @\"(/Users/[^/]+).*\"\n withString: @\"$1\" options: NSRegularExpressionSearch\n range: NSMakeRange(0, file.length)].UTF8String;\n #endif\n int hash = 0;\n for (size_t i=0, len = strlen(key); i> 24) {\n case 10: // mobile network\n// case 172: // hotspot\n case 127: // loopback\n return;\n }\n int idx = if_nametoindex(ifa->ifa_name);\n setsockopt(multicastSocket, IPPROTO_IP, IP_BOUND_IF, &idx, sizeof idx);\n addr.sin_addr.s_addr = laddr | ~nmask;\n printf(\"Broadcasting to %s.%d:%s to locate InjectionIII host...\\n\",\n ifa->ifa_name, idx, inet_ntoa(addr.sin_addr));\n if (sendto(multicastSocket, &msgbuf, sizeof msgbuf, 0,\n (struct sockaddr *)&addr, sizeof addr) < 0)\n [self error:@\"Could not send broadcast ping: %s\"];\n }];\n\n socklen_t addrlen = sizeof addr;\n while (recvfrom(multicastSocket, &msgbuf, sizeof msgbuf, 0,\n (struct sockaddr *)&addr, &addrlen) < sizeof msgbuf) {\n [self error:@\"%s: Error receiving from broadcast: %s\"];\n sleep(1);\n }\n\n const char *ipaddr = inet_ntoa(addr.sin_addr);\n printf(format, msgbuf.host, ipaddr);\n close(multicastSocket);\n return [NSString stringWithUTF8String:ipaddr];\n}\n\n@end\n#endif\n"
},
{
"path": "Sources/HotReloadingGuts/Unhide.mm",
"content": "//\n// Unhide.mm\n//\n// Created by John Holdsworth on 07/03/2021.\n//\n// Removes \"hidden\" visibility for certain Swift symbols\n// (default argument generators) so they can be referenced\n// in a file being dynamically loaded.\n//\n// $Id: //depot/HotReloading/Sources/HotReloadingGuts/Unhide.mm#52 $\n//\n\n#if DEBUG || !SWIFT_PACKAGE\n#import \n\n#import \n#import \n#import \n#import \n#import \n#import \n#import \n#import