diff --git a/unified/ql/lib/codeql/unified/internal/AnalysisQuality.qll b/unified/ql/lib/codeql/unified/internal/AnalysisQuality.qll index b0449cef77a8..79bac4423ccd 100644 --- a/unified/ql/lib/codeql/unified/internal/AnalysisQuality.qll +++ b/unified/ql/lib/codeql/unified/internal/AnalysisQuality.qll @@ -108,3 +108,28 @@ module CallGraphStats implements EntityStatsSig { } module CallGraphStatsReport = EntityReportStats; + +/** + * Gets summary statistics about taint. + */ +predicate taintStats(string key, int value) { + // The keys must match those in DCA summary profiles + key = "Taint sources - active" and value = count(DataFlow::Node n | Models::isSource(n, "remote")) + or + key = "Taint sources - disabled" and + value = count(DataFlow::Node n | Models::isSource(n, any(string s | s != "remote"))) + or + key = "Taint sources - sensitive data" and none() + or + key = "Taint edges - number of edges" and none() + or + key = "Taint reach - nodes tainted" and none() + or + key = "Taint reach - total non-summary nodes" and none() + or + key = "Taint reach - per million nodes" and none() + or + key = "Taint sinks - query sinks" and value = count(DataFlow::Node n | Models::isSink(n, _)) + or + key = "Taint sinks - cryptographic operations" and none() +} diff --git a/unified/ql/lib/codeql/unified/internal/FacadeAst.qll b/unified/ql/lib/codeql/unified/internal/FacadeAst.qll index 31b3ec3d950d..9020c167b798 100644 --- a/unified/ql/lib/codeql/unified/internal/FacadeAst.qll +++ b/unified/ql/lib/codeql/unified/internal/FacadeAst.qll @@ -5,6 +5,7 @@ overlay[local?] module; private import codeql.files.FileSystem +private import codeql.unified.internal.NameBinding as NameBinding module Unified { private import Ast::Unified as G @@ -145,6 +146,13 @@ module Unified { class ClassLikeDeclaration extends G::ClassLikeDeclaration { /** Gets the name of this declaration. */ string getName() { result = this.getNameNode().getValue() } + + /** Gets a direct base class of this class. */ + ClassLikeDeclaration getABaseClass() { + result.getNameNode() = + NameBinding::getStaticBindingTarget(NameBinding::getIdentifierFromRef(this.getABaseType() + .getType())) + } } class ConstructorDeclaration extends G::ConstructorDeclaration { @@ -260,5 +268,10 @@ module Unified { /** Gets the number of arguments passed to this call, not counting implicit arguments like receiver. */ int getNumberOfArguments() { result = count(this.getAnArgument()) } + + /** Gets the number of positional arguments passed to this call. */ + int getNumberOfPositionalArguments() { + result = count(Argument arg | arg = this.getAnArgument() and arg.isPositional()) + } } } diff --git a/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowGraph.qll b/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowGraph.qll index 4ba0fdcb802c..91111f7f8c0d 100644 --- a/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowGraph.qll +++ b/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowGraph.qll @@ -148,7 +148,7 @@ module DebugGraph { if isUseStep = true then value = "use-use" else value = "def-use" ) or - node2 = getPostUpdateNode(node1) and + node2 = node1.getPostUpdateNode() and value = "post-update" ) } diff --git a/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowInstantiation.qll b/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowInstantiation.qll index b2d455eb058e..c762ec0de7d0 100644 --- a/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowInstantiation.qll +++ b/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowInstantiation.qll @@ -101,9 +101,9 @@ module DataFlowInput implements InputSig { // Post-update nodes // class PostUpdateNode extends Node { - PostUpdateNode() { this = getPostUpdateNode(_) } + PostUpdateNode() { this = any(Node n).getPostUpdateNode() } - Node getPreUpdateNode() { this = getPostUpdateNode(result) } + Node getPreUpdateNode() { this = result.getPostUpdateNode() } } // diff --git a/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowNode.qll b/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowNode.qll index 03b01096848f..0c92899205c2 100644 --- a/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowNode.qll +++ b/unified/ql/lib/codeql/unified/internal/dataflow/DataFlowNode.qll @@ -315,21 +315,27 @@ class Node extends TDataFlowNode { /** Gets the basic block associated with this data flow node, if any. */ BasicBlock getBasicBlock() { this.hasControlFlowPosition(result, _) } -} -Node getPostUpdateNode(Node pre) { - exists(Expr expr | - pre.isResultValue(expr) and - result.isPostUpdate(expr) - ) - or - exists(Expr expr, LocalVariable var | - pre.isLocalVariableRead(expr, var) and - result.isLocalVariablePostUpdate(expr, var) - ) - or - exists(DataFlowCall call | - pre.isReceiverArgumentEx(call) and - result.isReceiverPostUpdateEx(call) - ) + /** + * Gets the post-update node for this node, if any. + * + * The post-update node represents the updated state of the value held in this node, after it has been mutated by the surrounding assignment or call. + */ + pragma[nomagic] + Node getPostUpdateNode() { + exists(Expr expr | + this.isResultValue(expr) and + result.isPostUpdate(expr) + ) + or + exists(Expr expr, LocalVariable var | + this.isLocalVariableRead(expr, var) and + result.isLocalVariablePostUpdate(expr, var) + ) + or + exists(DataFlowCall call | + this.isReceiverArgumentEx(call) and + result.isReceiverPostUpdateEx(call) + ) + } } diff --git a/unified/ql/lib/codeql/unified/internal/dataflow/LocalSsa.qll b/unified/ql/lib/codeql/unified/internal/dataflow/LocalSsa.qll index 56c2cfadea73..dd3b41492061 100644 --- a/unified/ql/lib/codeql/unified/internal/dataflow/LocalSsa.qll +++ b/unified/ql/lib/codeql/unified/internal/dataflow/LocalSsa.qll @@ -95,7 +95,7 @@ Node getNodeFromLocalSsaNode(Ssa::Node n) { result = n.(Ssa::ExprNode).getExpr() and not postUpdateReadNode(n) or - result = getPostUpdateNode(n.(Ssa::ExprPostUpdateNode).getExpr()) + result = n.(Ssa::ExprPostUpdateNode).getExpr().(Node).getPostUpdateNode() or exists(LocalVariable v, BasicBlock bb, int i, AstNode repr | n.(Ssa::WriteDefSourceNode).getDefinition().definesAt(v, bb, i) and diff --git a/unified/ql/lib/codeql/unified/internal/mad/LegacyMaD.qll b/unified/ql/lib/codeql/unified/internal/mad/LegacyMaD.qll new file mode 100644 index 000000000000..492ef6abc453 --- /dev/null +++ b/unified/ql/lib/codeql/unified/internal/mad/LegacyMaD.qll @@ -0,0 +1,363 @@ +/** + * Provides an approximate interpreter for MaD models imported from legacy Swift. + */ + +private import unified +private import codeql.dataflow.internal.AccessPathSyntax + +extensible predicate legacySourceModel( + string namespace, string type, boolean subtypes, string name, string signature, string ext, + string output, string kind, string provenance +); + +extensible predicate legacySinkModel( + string namespace, string type, boolean subtypes, string name, string signature, string ext, + string input, string kind, string provenance +); + +extensible predicate legacySummaryModel( + string namespace, string type, boolean subtypes, string name, string signature, string ext, + string input, string output, string kind, string provenance +); + +private predicate modelContainsMethodName(string name) { + legacySourceModel(_, _, _, name, _, _, _, _, _) + or + legacySinkModel(_, _, _, name, _, _, _, _, _) + or + legacySummaryModel(_, _, _, name, _, _, _, _, _, _) +} + +private predicate parsedRawMethodName(string rawName, string name, string argLabels) { + // NOTE: We only support method names at the moment, not property names like `String.count`. + modelContainsMethodName(rawName) and + exists(string regex | + regex = "([^(]+)\\((.*)\\)" and + name = rawName.regexpCapture(regex, 1) and + argLabels = rawName.regexpCapture(regex, 2) + ) +} + +private string getSimpleNameFromExpr(Expr e) { + result = e.(Identifier).getValue() + or + result = e.(MemberAccessExpr).getMemberName() +} + +private string getQualifiedNameFromExpr(Expr e) { + result = e.(Identifier).getValue() + or + exists(MemberAccessExpr access | e = access | + result = getQualifiedNameFromExpr(access.getBase()) + "." + access.getMemberName() + ) +} + +private string getArgLabelsFromCall(CallExpr call) { + result = + concat(Argument arg, string name, int group | + arg = call.getAnArgument() and + ( + arg.isPositional() and + name = "_" and + group = 0 + or + name = arg.getName() and + group = 1 + ) + | + name + ":" order by group, name + ) +} + +pragma[nomagic] +private predicate methodCallSelector(CallExpr call, string name, string argLabels) { + name = getSimpleNameFromExpr(call.getCallee()) and + argLabels = getArgLabelsFromCall(call) +} + +pragma[nomagic] +private predicate constructorCallSelector(CallExpr call, string name, string argLabels) { + ( + if call.getCallee().(MemberAccessExpr).getMemberName() = "init" + then name = getQualifiedNameFromExpr(call.getCallee().(MemberAccessExpr).getBase()) + else name = getQualifiedNameFromExpr(call.getCallee()) + ) and + argLabels = getArgLabelsFromCall(call) +} + +private predicate isSubclassOfType(ClassLikeDeclaration cls, string typeName) { + typeName = any(Selector s).getTypeString() and + ( + getQualifiedNameFromExpr(cls.getABaseType().getType()) = typeName + or + isSubclassOfType(cls.getABaseClass(), typeName) + ) +} + +private string getArgLabelsFromCallable(Callable callable) { + result = + concat(Parameter param, string name, int group | + param.getParent() = callable and + ( + param.isPositional() and + name = "_" and + group = 0 + or + name = param.getExternalName() and + group = 1 + ) + | + name + ":" order by group, name + ) +} + +pragma[nomagic] +private predicate callableSelector( + FunctionDeclaration callable, string type, string name, string argLabels +) { + name = callable.getName() and + argLabels = getArgLabelsFromCallable(callable) and + exists(ClassLikeDeclaration cls | + callable = cls.getAMember() and + isSubclassOfType(cls, type) + ) +} + +private newtype TSelector = + MkSelector(string type, boolean subtypes, string name, string argLabels, string argTypes) { + exists(string rawName | + legacySourceModel(_, type, subtypes, rawName, argTypes, _, _, _, _) + or + legacySinkModel(_, type, subtypes, rawName, argTypes, _, _, _, _) + or + legacySummaryModel(_, type, subtypes, rawName, argTypes, _, _, _, _, _) + | + parsedRawMethodName(rawName, name, argLabels) + ) + } + +/** + * A tuple from a model that identifies call sites. + */ +private class Selector extends TSelector { + string getTypeString() { this = MkSelector(result, _, _, _, _) } + + boolean getSubtypesFlag() { this = MkSelector(_, result, _, _, _) } + + string getName() { this = MkSelector(_, _, result, _, _) } + + string getArgLabels() { this = MkSelector(_, _, _, result, _) } + + string getArgTypes() { this = MkSelector(_, _, _, _, result) } + + private string ppSubtypes() { + if this.getSubtypesFlag() = true then result = "+" else result = "" + } + + string toString() { + result = + this.getTypeString() + this.ppSubtypes() + "." + this.getName() + "(" + this.getArgLabels() + + ")" + this.getArgTypes() + } + + /** Holds if `name,argLabels` should be used to join with `methodCallSelector`. */ + pragma[nomagic] + private predicate matchesMethodCallSelector(string name, string argLabels) { + this = MkSelector(_, _, name, argLabels, _) and + name != "init" + } + + /** Holds if `name,argLabels` should be used to join with `constructorCallSelector`. */ + pragma[nomagic] + private predicate matchesConstructorCallSelector(string name, string argLabels) { + this = MkSelector(name, _, "init", argLabels, _) + } + + predicate matchesCall(CallExpr call) { + exists(string name, string argLabels | + this.matchesMethodCallSelector(name, argLabels) and + methodCallSelector(call, name, argLabels) + or + this.matchesConstructorCallSelector(name, argLabels) and + constructorCallSelector(call, name, argLabels) + ) + } + + predicate matchesCallable(Callable callable) { + exists(string type, string name, string argLabels | + callableSelector(callable, type, name, argLabels) and + this = MkSelector(type, true, name, argLabels, _) + ) + } + + int getPositionalArity() { result = count(int n | this.getArgLabels().splitAt(":", n) = "_") } + + string getANamedArgument() { result = this.getArgLabels().splitAt(":") and result != "_" } +} + +private predicate isAccessPath(string path) { + legacySourceModel(_, _, _, _, _, _, path, _, _) // output + or + legacySinkModel(_, _, _, _, _, _, path, _, _) // input + or + legacySummaryModel(_, _, _, _, _, _, path, _, _, _) // input + or + legacySummaryModel(_, _, _, _, _, _, _, path, _, _) // output +} + +private module AccessPathOutput = AccessPath; + +private import AccessPathOutput + +/** + * Gets the input to `call` specified by `token`. Only singleton access paths are supported. + */ +bindingset[call, token] +private DataFlow::Node getSinkFromCall(CallExpr call, AccessPathToken token) { + token.getName() = "Argument" and + exists(Argument arg | + arg = call.getAnArgument() and + result.asExpr() = arg.getValue() + | + arg.getPositionalIndex() = parseIntUnbounded(token.getAnArgument()) + or + arg.getName() + ":" = token.getAnArgument() + ) + or + token = "Argument[self]" and + result.isReceiverArgument(call) +} + +/** + * Gets the output from `call` specified by `token`. Only singleton access paths are supported. + */ +bindingset[call, token] +private DataFlow::Node getSourceFromCall(CallExpr call, AccessPathToken token) { + token = "ReturnValue" and + result.asExpr() = call + or + result = getSinkFromCall(call, token).getPostUpdateNode() +} + +/** + * Gets the sink from `callable` specified by `token`. Only singleton access paths are supported. + */ +bindingset[callable, token] +private DataFlow::Node getSinkFromCallable(Callable callable, AccessPathToken token) { + token = "ReturnValue" and + result.asExpr() = any(ReturnExpr r | r.getEnclosingCallable() = callable).getValue() // TODO: expose canonical return node in data flow +} + +/** + * Gets the source from `callable` specified by `token`. Only singleton access paths are supported. + */ +bindingset[callable, token] +private DataFlow::Node getSourceFromCallable(Callable callable, AccessPathToken token) { + token.getName() = "Parameter" and + exists(Parameter param | + param.getParent() = callable and + result.asExpr() = param.getPattern() + | + param.getPositionalIndex() = parseIntUnbounded(token.getAnArgument()) + or + param.getExternalName() + ":" = token.getAnArgument() + ) + or + token = "Parameter[self]" and + result.isReceiverParameter(callable) +} + +private predicate normalizedSourceModel( + Selector selector, AccessPath output, string kind, string provenance +) { + exists( + string type, boolean subtypes, string rawName, string name, string argLabels, string argTypes + | + legacySourceModel(_, type, subtypes, rawName, argTypes, _, output, kind, provenance) and + parsedRawMethodName(rawName, name, argLabels) and + selector = MkSelector(type, subtypes, name, argLabels, argTypes) + ) +} + +private predicate normalizedSinkModel( + Selector selector, AccessPath output, string kind, string provenance +) { + exists( + string type, boolean subtypes, string rawName, string name, string argLabels, string argTypes + | + legacySinkModel(_, type, subtypes, rawName, argTypes, _, output, kind, provenance) and + parsedRawMethodName(rawName, name, argLabels) and + selector = MkSelector(type, subtypes, name, argLabels, argTypes) + ) +} + +/** + * Gets a flow source with the given `kind` and `provenance`. + */ +DataFlow::Node getASource(string kind, string provenance) { + exists(Selector selector, AccessPath output | + normalizedSourceModel(selector, output, kind, provenance) + | + exists(CallExpr call | + selector.matchesCall(call) and + result = getSourceFromCall(call, output) + ) + or + exists(Callable callable | + selector.matchesCallable(callable) and + result = getSourceFromCallable(callable, output) + ) + ) +} + +/** + * Gets a sink with the given `kind` and `provenance`. + */ +DataFlow::Node getASink(string kind, string provenance) { + exists(Selector selector, AccessPath input | + normalizedSinkModel(selector, input, kind, provenance) + | + exists(CallExpr call | + selector.matchesCall(call) and + result = getSinkFromCall(call, input) + ) + or + exists(Callable callable | + selector.matchesCallable(callable) and + result = getSinkFromCallable(callable, input) + ) + ) +} + +module Public { + /** Provides access to data from library models. */ + module Models { + /** Holds if `node` is a source of the given `kind`. */ + predicate isSource(DataFlow::Node node, string kind) { node = getASource(kind, _) } + + /** Holds if `node` is a sink of the given `kind`. */ + predicate isSink(DataFlow::Node node, string kind) { node = getASink(kind, _) } + } +} + +private module Debug { + query predicate invalidAccessPath(Selector selector, AccessPathToken ap) { + ( + normalizedSourceModel(selector, ap, _, _) + or + normalizedSinkModel(selector, ap, _, _) + ) and + ap.getName() = ["Argument", "Parameter"] and + ( + exists(int n | + parseInt(ap.getAnArgument()) = n and + not n in [0 .. selector.getPositionalArity() - 1] + ) + or + exists(string name | + name = ap.getAnArgument().regexpCapture("(.*):", 1) and + not name = selector.getANamedArgument() + ) + ) + } +} diff --git a/unified/ql/lib/ext/legacy-swift.model.yml b/unified/ql/lib/ext/legacy-swift.model.yml new file mode 100644 index 000000000000..a44a48adada5 --- /dev/null +++ b/unified/ql/lib/ext/legacy-swift.model.yml @@ -0,0 +1,1185 @@ +extensions: + - addsTo: + pack: codeql/unified-all + extensible: legacySourceModel + data: # namespace, type, subtypes, name, signature, ext, output, kind, provenance + - ["", "String", true, "count", "", "", "", "string-length", "manual"] + - ["", "String", true, "init(contentsOf:)", "(URL)", "", "ReturnValue", "remote", "manual"] + - ["", "String", true, "init(contentsOfFile:)", "(String)", "", "ReturnValue", "local", "manual"] + - ["", "String", true, "init(contentsOf:encoding:)", "(URL,String.Encoding)", "", "ReturnValue", "remote", "manual"] + - ["", "String", true, "init(contentsOfFile:encoding:)", "(String,String.Encoding)", "", "ReturnValue", "local", "manual"] + - ["", "String", true, "init(contentsOf:usedEncoding:)", "(URL,String.Encoding)", "", "ReturnValue", "remote", "manual"] + - ["", "String", true, "init(contentsOfFile:usedEncoding:)", "(String,String.Encoding)", "", "ReturnValue", "local", "manual"] + - ["", "", false, "SecKeyCopyExternalRepresentation(_:_:)", "", "", "ReturnValue", "sensitive-password", "manual"] + - ["", "URL", true, "lines", "", "", "", "remote", "manual"] + - ["", "URL", true, "resourceBytes", "", "", "", "remote", "manual"] + - ["", "UITextField", true, "text", "", "", "", "local", "manual"] + - ["", "UITextField", true, "attributedText", "", "", "", "local", "manual"] + - ["", "DataResponse", true, "value", "", "", "", "remote", "manual"] + - ["", "DataResponse", true, "result", "", "", "", "remote", "manual"] + - ["", "DataResponse", true, "data", "", "", "", "remote", "manual"] + - ["", "URL.AsyncBytes", true, "lines", "", "", "", "remote", "manual"] + - ["", "DownloadResponse", true, "value", "", "", "", "remote", "manual"] + - ["", "DownloadResponse", true, "result", "", "", "", "remote", "manual"] + - ["", "DownloadResponse", true, "data", "", "", "", "remote", "manual"] + - ["", "JSContext", true, "globalObject", "", "", "", "remote", "manual"] + - ["", "JSContext", true, "objectForKeyedSubscript(_:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "JSContext", true, "objectAtIndexedSubscript(_:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "UITextInput", true, "text(in:)", "", "", "ReturnValue", "local", "manual"] + - ["", "UITextInput", true, "shouldChangeText(in:replacementText:)", "", "", "Parameter[replacementText:]", "local", "manual"] + - ["", "NSData", true, "init(contentsOf:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "NSData", true, "init(contentsOf:options:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "NSString", true, "length", "", "", "", "nsstring-length", "manual"] + - ["", "NSString", true, "init(contentsOf:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "NSString", true, "init(contentsOfFile:)", "", "", "ReturnValue", "local", "manual"] + - ["", "NSString", true, "string(withContentsOf:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "NSString", true, "init(contentsOf:encoding:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "NSString", true, "string(withContentsOfFile:)", "", "", "ReturnValue", "local", "manual"] + - ["", "NSString", true, "init(contentsOfFile:encoding:)", "", "", "ReturnValue", "local", "manual"] + - ["", "NSString", true, "init(contentsOf:usedEncoding:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "NSString", true, "init(contentsOfFile:usedEncoding:)", "", "", "ReturnValue", "local", "manual"] + - ["", "FileManager", true, "contents(atPath:)", "", "", "ReturnValue", "local", "manual"] + - ["", "Data", true, "init(contentsOf:options:)", "", "", "ReturnValue", "remote", "manual"] + - ["", "UISceneDelegate", true, "scene(_:continue:)", "", "", "Parameter[continue:]", "remote", "manual"] + - ["", "UISceneDelegate", true, "scene(_:didUpdate:)", "", "", "Parameter[didUpdate:]", "remote", "manual"] + - ["", "UISceneDelegate", true, "scene(_:openURLContexts:)", "", "", "Parameter[openURLContexts:]", "remote", "manual"] + - ["", "UISceneDelegate", true, "scene(_:options:willConnectTo:)", "", "", "Parameter[options:]", "remote", "manual"] + - ["", "UIApplicationDelegate", true, "application(_:handleOpen:)", "", "", "Parameter[handleOpen:]", "remote", "manual"] + - ["", "UIApplicationDelegate", true, "application(_:open:options:)", "", "", "Parameter[open:]", "remote", "manual"] + - ["", "UIApplicationDelegate", true, "application(_:annotation:open:sourceApplication:)", "", "", "Parameter[open:]", "remote", "manual"] + - ["", "WKScriptMessageHandler", true, "userContentController(_:didReceive:)", "", "", "Parameter[didReceive:]", "remote", "manual"] + - ["", "UITextViewDelegate", true, "textView(_:replacementText:shouldChangeTextIn:)", "", "", "Parameter[replacementText:]", "local", "manual"] + - ["", "UITextFieldDelegate", true, "textField(_:replacementString:shouldChangeCharactersIn:)", "", "", "Parameter[replacementString:]", "local", "manual"] + - ["", "NSMutableString", true, "length", "", "", "", "nsstring-length", "manual"] + - addsTo: + pack: codeql/unified-all + extensible: legacySinkModel + data: # namespace, type, subtypes, name, signature, ext, input, kind, provenance + - ["", "String", true, "index(_:offsetBy:)", "", "", "Argument[0,offsetBy:]", "string-length", "manual"] + - ["", "String", true, "init(contentsOfFile:)", "", "", "Argument[contentsOfFile:]", "path-injection", "manual"] + - ["", "String", true, "init(contentsOfFile:encoding:)", "", "", "Argument[contentsOfFile:]", "path-injection", "manual"] + - ["", "String", true, "init(contentsOfFile:usedEncoding:)", "", "", "Argument[contentsOfFile:]", "path-injection", "manual"] + - ["", "String", true, "index(_:limitBy:offsetBy:)", "", "", "Argument[0,offsetBy:]", "string-length", "manual"] + - ["", "String", true, "md5()", "", "", "Argument[self]", "weak-hash-input-MD5", "manual"] + - ["", "String", true, "sha1()", "", "", "Argument[self]", "weak-hash-input-SHA1", "manual"] + - ["", "String", true, "sha2(_:)", "", "", "Argument[self]", "weak-password-hash-input-SHA2", "manual"] + - ["", "String", true, "sha224()", "", "", "Argument[self]", "weak-password-hash-input-SHA224", "manual"] + - ["", "String", true, "sha256()", "", "", "Argument[self]", "weak-password-hash-input-SHA256", "manual"] + - ["", "String", true, "sha3(_:)", "", "", "Argument[self]", "weak-password-hash-input-SHA3", "manual"] + - ["", "String", true, "sha384()", "", "", "Argument[self]", "weak-password-hash-input-SHA384", "manual"] + - ["", "String", true, "sha512()", "", "", "Argument[self]", "weak-password-hash-input-SHA512", "manual"] + - ["", "Array", true, "md5()", "", "", "Argument[self]", "weak-hash-input-MD5", "manual"] + - ["", "Array", true, "sha1()", "", "", "Argument[self]", "weak-hash-input-SHA1", "manual"] + - ["", "Array", true, "sha2(_:)", "", "", "Argument[self]", "weak-password-hash-input-SHA2", "manual"] + - ["", "Array", true, "sha224()", "", "", "Argument[self]", "weak-password-hash-input-SHA224", "manual"] + - ["", "Array", true, "sha256()", "", "", "Argument[self]", "weak-password-hash-input-SHA256", "manual"] + - ["", "Array", true, "sha3(_:)", "", "", "Argument[self]", "weak-password-hash-input-SHA3", "manual"] + - ["", "Array", true, "sha384()", "", "", "Argument[self]", "weak-password-hash-input-SHA384", "manual"] + - ["", "Array", true, "sha512()", "", "", "Argument[self]", "weak-password-hash-input-SHA512", "manual"] + - ["", "String.Index", true, "init(encodedOffset:)", "", "", "Argument[encodedOffset:]", "string-length", "manual"] + - ["", "Regex", true, "init(_:)", "", "", "Argument[0]", "regex-use", "manual"] + - ["", "Regex", true, "init(_:as:)", "", "", "Argument[0]", "regex-use", "manual"] + - ["", "", false, "assert(_:_:file:line:)", "", "", "Argument[1]", "log-injection", "manual"] + - ["", "", false, "precondition(_:_:file:line:)", "", "", "Argument[1]", "log-injection", "manual"] + - ["", "", false, "assertionFailure(_:file:line:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "", false, "preconditionFailure(_:file:line:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "", false, "fatalError(_:file:line:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "", false, "dump(_:indent:maxDepth:maxItems:name:)", "", "", "Argument[0,name:]", "log-injection", "manual"] + - ["", "", false, "print(_:separator:terminator:)", "", "", "Argument[0,separator:,terminator:]", "log-injection", "manual"] + - ["", "", false, "debugPrint(_:separator:terminator:)", "", "", "Argument[0,separator:,terminator:]", "log-injection", "manual"] + - ["", "", false, "NSMakeRange(_:_:)", "", "", "Argument[0,1]", "nsstring-length", "manual"] + - ["", "", false, "sqlite3_key(_:_:_:)", "", "", "Argument[1]", "encryption-key", "manual"] + - ["", "", false, "sqlite3_key_v2(_:_:_:_:)", "", "", "Argument[2]", "encryption-key", "manual"] + - ["", "", false, "sqlite3_rekey(_:_:_:)", "", "", "Argument[1]", "encryption-key", "manual"] + - ["", "", false, "sqlite3_rekey_v2(_:_:_:_:)", "", "", "Argument[2]", "encryption-key", "manual"] + - ["", "", false, "NSLog(_:_:)", "", "", "Argument[0,1]", "log-injection", "manual"] + - ["", "", false, "NSLogv(_:_:)", "", "", "Argument[0,1]", "log-injection", "manual"] + - ["", "", false, "os_log(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "", false, "os_log(_:_:_:dso:log:)", "", "", "Argument[0,2]", "log-injection", "manual"] + - ["", "", false, "os_log(_:_:dso:log:type:)", "", "", "Argument[0,1]", "log-injection", "manual"] + - ["", "", false, "os_log(_:_:log:)", "", "", "Argument[1]", "log-injection", "manual"] + - ["", "", false, "print(_:separator:terminator:toStream:)", "", "", "Argument[0,separator:,terminator:]", "log-injection", "manual"] + - ["", "", false, "vfprintf(_:_:_:)", "", "", "Argument[1,2]", "log-injection", "manual"] + - ["", "", false, "sqlite3_bind_blob(_:_:_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_blob64(_:_:_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_double(_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_int(_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_int64(_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_pointer(_:_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_text(_:_:_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_text16(_:_:_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_text64(_:_:_:_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_bind_value(_:_:_:)", "", "", "Argument[2]", "database-store", "manual"] + - ["", "", false, "sqlite3_exec(_:_:_:_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "", false, "sqlite3_prepare(_:_:_:_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "", false, "sqlite3_prepare16(_:_:_:_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "", false, "sqlite3_prepare16_v2(_:_:_:_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "", false, "sqlite3_prepare16_v3(_:_:_:_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "", false, "sqlite3_prepare_v2(_:_:_:_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "", false, "sqlite3_prepare_v3(_:_:_:_:_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "", false, "sqlite3_database_file_object(_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "", false, "sqlite3_filename_database(_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "", false, "sqlite3_filename_journal(_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "", false, "sqlite3_filename_wal(_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "", false, "sqlite3_free_filename(_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "", false, "sqlite3_open(_:_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "", false, "sqlite3_open16(_:_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "", false, "sqlite3_open_v2(_:_:_:_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "NSData", true, "init(contentsOf:)", "", "", "Argument[contentsOf:]", "path-injection", "manual"] + - ["", "NSData", true, "init(contentsOfFile:)", "", "", "Argument[contentsOfFile:]", "path-injection", "manual"] + - ["", "NSData", true, "init(contentsOf:options:)", "", "", "Argument[contentsOf:]", "path-injection", "manual"] + - ["", "NSData", true, "dataWithContentsOfMappedFile(_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "NSData", true, "init(contentsOfFile:options:)", "", "", "Argument[contentsOfFile:]", "path-injection", "manual"] + - ["", "NSData", true, "init(contentsOfMappedFile:)", "", "", "Argument[contentsOfMappedFile:]", "path-injection", "manual"] + - ["", "NSData", true, "write(options:to:)", "", "", "Argument[to:]", "path-injection", "manual"] + - ["", "NSData", true, "write(atomically:to:)", "", "", "Argument[to:]", "path-injection", "manual"] + - ["", "NSData", true, "write(atomically:toFile:)", "", "", "Argument[toFile:]", "path-injection", "manual"] + - ["", "NSData", true, "write(options:toFile:)", "", "", "Argument[toFile:]", "path-injection", "manual"] + - ["", "NSString", true, "character(at:)", "", "", "Argument[at:]", "nsstring-length", "manual"] + - ["", "NSString", true, "init(contentsOfFile:encoding:)", "", "", "Argument[contentsOfFile:]", "path-injection", "manual"] + - ["", "NSString", true, "init(contentsOfFile:usedEncoding:)", "", "", "Argument[contentsOfFile:]", "path-injection", "manual"] + - ["", "NSString", true, "substring(from:)", "", "", "Argument[from:]", "nsstring-length", "manual"] + - ["", "NSString", true, "substring(to:)", "", "", "Argument[to:]", "nsstring-length", "manual"] + - ["", "NSString", true, "write(atomically:encoding:to:)", "", "", "Argument[to:]", "path-injection", "manual"] + - ["", "NSString", true, "write(atomically:encoding:toFile:)", "", "", "Argument[toFile:]", "path-injection", "manual"] + - ["", "FileManager", true, "contents(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "unzipItem(at:pathEncoding:progress:skipCRC32:to:)", "", "", "Argument[at:]", "unsafe-unpack", "manual"] + - ["", "FileManager", true, "attributesOfItem(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "changeCurrentDirectoryPath(_:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "FileManager", true, "changeFileAttributes(_:atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "contentsEqual(andPath:atPath:)", "", "", "Argument[atPath:,andPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "contentsOfDirectory(at:includingPropertiesForKeys:options:)", "", "", "Argument[at:]", "path-injection", "manual"] + - ["", "FileManager", true, "contentsOfDirectory(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "copyItem(at:to:)", "", "", "Argument[at:,to:]", "path-injection", "manual"] + - ["", "FileManager", true, "copyItem(atPath:toPath:)", "", "", "Argument[atPath:,toPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "createDirectory(at:attributes:withIntermediateDirectories:)", "", "", "Argument[at:]", "path-injection", "manual"] + - ["", "FileManager", true, "createDirectory(atPath:attributes:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "createDirectory(atPath:attributes:withIntermediateDirectories:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "createFile(atPath:attributes:contents:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "createSymbolicLink(at:withDestinationURL:)", "", "", "Argument[at:,withDestinationURL:]", "path-injection", "manual"] + - ["", "FileManager", true, "createSymbolicLink(atPath:pathContent:)", "", "", "Argument[atPath:,pathContent:]", "path-injection", "manual"] + - ["", "FileManager", true, "createSymbolicLink(atPath:withDestinationPath:)", "", "", "Argument[atPath:,withDestinationPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "destinationOfSymbolicLink(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "directoryContents(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "enumerator(at:errorHandler:includingPropertiesForKeys:options:)", "", "", "Argument[at:]", "path-injection", "manual"] + - ["", "FileManager", true, "enumerator(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "fileAttributes(atPath:traverseLink:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "fileExists(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "fileExists(atPath:isDirectory:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "linkItem(at:to:)", "", "", "Argument[at:,to:]", "path-injection", "manual"] + - ["", "FileManager", true, "linkItem(atPath:toPath:)", "", "", "Argument[atPath:,toPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "moveItem(at:to:)", "", "", "Argument[at:,to:]", "path-injection", "manual"] + - ["", "FileManager", true, "moveItem(atPath:toPath:)", "", "", "Argument[atPath:,toPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "pathContentOfSymbolicLink(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "removeItem(at:)", "", "", "Argument[at:]", "path-injection", "manual"] + - ["", "FileManager", true, "removeItem(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "replaceItem(at:backupItemName:options:resultingItemURL:withItemAt:)", "", "", "Argument[at:,withItemAt:]", "path-injection", "manual"] + - ["", "FileManager", true, "replaceItemAt(_:backupItemName:options:withItemAt:)", "", "", "Argument[0,withItemAt:]", "path-injection", "manual"] + - ["", "FileManager", true, "replaceItemAtURL(backupItemName:options:originalItemURL:withItemAtURL:)", "", "", "Argument[originalItemURL:,withItemAtURL:]", "path-injection", "manual"] + - ["", "FileManager", true, "setAttributes(_:ofItemAtPath:)", "", "", "Argument[ofItemAtPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "subpaths(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "subpathsOfDirectory(atPath:)", "", "", "Argument[atPath:]", "path-injection", "manual"] + - ["", "FileManager", true, "trashItem(at:resultingItemURL:)", "", "", "Argument[at:]", "path-injection", "manual"] + - ["", "FileManager", true, "unmountVolume(at:completionHandler:options:)", "", "", "Argument[at:]", "path-injection", "manual"] + - ["", "Data", true, "init(contentsOf:options:)", "", "", "Argument[contentsOf:]", "path-injection", "manual"] + - ["", "Data", true, "md5()", "", "", "Argument[self]", "weak-hash-input-MD5", "manual"] + - ["", "Data", true, "sha1()", "", "", "Argument[self]", "weak-hash-input-SHA1", "manual"] + - ["", "Data", true, "sha2(_:)", "", "", "Argument[self]", "weak-password-hash-input-SHA2", "manual"] + - ["", "Data", true, "sha224()", "", "", "Argument[self]", "weak-password-hash-input-SHA224", "manual"] + - ["", "Data", true, "sha256()", "", "", "Argument[self]", "weak-password-hash-input-SHA256", "manual"] + - ["", "Data", true, "sha3(_:)", "", "", "Argument[self]", "weak-password-hash-input-SHA3", "manual"] + - ["", "Data", true, "sha384()", "", "", "Argument[self]", "weak-password-hash-input-SHA384", "manual"] + - ["", "Data", true, "sha512()", "", "", "Argument[self]", "weak-password-hash-input-SHA512", "manual"] + - ["", "Data", true, "write(options:to:)", "", "", "Argument[to:]", "path-injection", "manual"] + - ["", "NSMutableString", true, "insert(_:at:)", "", "", "Argument[at:]", "nsstring-length", "manual"] + - ["", "NSMutableString", true, "character(at:)", "", "", "Argument[at:]", "nsstring-length", "manual"] + - ["", "NSMutableString", true, "substring(from:)", "", "", "Argument[from:]", "nsstring-length", "manual"] + - ["", "NSMutableString", true, "substring(to:)", "", "", "Argument[to:]", "nsstring-length", "manual"] + - ["", "AES", true, "init(blockMode:key:)", "", "", "Argument[blockMode:]", "encryption-block-mode", "manual"] + - ["", "AES", true, "init(blockMode:key:padding:)", "", "", "Argument[blockMode:]", "encryption-block-mode", "manual"] + - ["", "NSPredicate", true, "init(_:format:)", "", "", "Argument[format:]", "predicate-injection", "manual"] + - ["", "NSPredicate", true, "init(arguments:format:)", "", "", "Argument[format:]", "predicate-injection", "manual"] + - ["", "NSPredicate", true, "init(argumentArray:format:)", "", "", "Argument[format:]", "predicate-injection", "manual"] + - ["", "NSPredicate", true, "init(fromMetadataQueryString:)", "", "", "Argument[fromMetadataQueryString:]", "predicate-injection", "manual"] + - ["", "NSRegularExpression", true, "init(options:pattern:)", "", "", "Argument[pattern:]", "regex-use", "manual"] + - ["", "Blowfish", true, "init(blockMode:key:padding:)", "", "", "Argument[blockMode:]", "encryption-block-mode", "manual"] + - ["", "URLSessionConfiguration", false, "tlsMaximumSupportedProtocol", "", "", "PostUpdate", "tls-protocol-version", "manual"] + - ["", "URLSessionConfiguration", false, "tlsMinimumSupportedProtocol", "", "", "PostUpdate", "tls-protocol-version", "manual"] + - ["", "URLSessionConfiguration", false, "tlsMaximumSupportedProtocolVersion", "", "", "PostUpdate", "tls-protocol-version", "manual"] + - ["", "URLSessionConfiguration", false, "tlsMinimumSupportedProtocolVersion", "", "", "PostUpdate", "tls-protocol-version", "manual"] + - ["", "NWConnection", true, "send(completion:content:contentContext:isComplete:)", "", "", "Argument[content:]", "transmission", "manual"] + - ["", "Zip", true, "unzipFile(_:destination:fileOutputHandler:overwrite:password:progress:)", "", "", "Argument[0]", "unsafe-unpack", "manual"] + - ["", "NSRange", true, "init(length:location:)", "", "", "Argument[location:,length:]", "nsstring-length", "manual"] + - ["", "NSUserScriptTask", true, "init(url:)", "", "", "Argument[url:]", "command-injection", "manual"] + - ["", "NSUserUnixTask", true, "execute(completionHandler:withArguments:)", "", "", "Argument[withArguments:]", "command-injection", "manual"] + - ["", "Process", true, "arguments", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "currentDirectory", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "currentDirectoryPath", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "environment", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "executableURL", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "launchPath", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "launchedProcess(arguments:launchPath:)", "", "", "Argument[launchPath:,arguments:]", "command-injection", "manual"] + - ["", "Process", true, "run(_:arguments:terminationHandler:)", "", "", "Argument[0,arguments:]", "command-injection", "manual"] + - ["", "Process", true, "standardError", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "standardInput", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Process", true, "standardOutput", "", "", "PostUpdate", "command-injection", "manual"] + - ["", "Connection", true, "key(_:db:)", "", "", "Argument[0]", "encryption-key", "manual"] + - ["", "Connection", true, "keyAndMigrate(_:db:)", "", "", "Argument[0]", "encryption-key", "manual"] + - ["", "Connection", true, "rekey(_:db:)", "", "", "Argument[0]", "encryption-key", "manual"] + - ["", "Connection", true, "sqlcipher_export(_:key:)", "", "", "Argument[key:]", "encryption-key", "manual"] + - ["", "Connection", true, "execute(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "Connection", true, "prepare(_:_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "Connection", true, "prepare(_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "Connection", true, "run(_:_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "Connection", true, "run(_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "Connection", true, "scalar(_:_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "Connection", true, "scalar(_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "Connection", true, "init(_:readonly:)", "", "", "Argument[0]", "path-injection", "manual"] + - ["", "Database", true, "changePassphrase(_:)", "", "", "Argument[0]", "encryption-key", "manual"] + - ["", "Database", true, "usePassphrase(_:)", "", "", "Argument[0]", "encryption-key", "manual"] + - ["", "Database", true, "allStatements(arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "Database", true, "execute(arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "Database", true, "init(configuration:description:path:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "Realm.Configuration", true, "encryptionKey", "", "", "PostUpdate", "encryption-key", "manual"] + - ["", "Realm.Configuration", true, "init(deleteRealmIfMigrationNeeded:encryptionKey:fileURL:inMemoryIdentifier:migrationBlock:objectTypes:readOnly:schemaVersion:shouldCompactOnLaunch:syncConfiguration:)", "", "", "Argument[fileURL:]", "path-injection", "manual"] + - ["", "Realm.Configuration", true, "init(deleteRealmIfMigrationNeeded:encryptionKey:fileURL:inMemoryIdentifier:migrationBlock:objectTypes:readOnly:schemaVersion:shouldCompactOnLaunch:syncConfiguration:)", "", "", "Argument[encryptionKey:]", "encryption-key", "manual"] + - ["", "Realm.Configuration", true, "init(deleteRealmIfMigrationNeeded:encryptionKey:fileURL:inMemoryIdentifier:migrationBlock:objectTypes:readOnly:schemaVersion:seedFilePath:shouldCompactOnLaunch:syncConfiguration:)", "", "", "Argument[fileURL:]", "path-injection", "manual"] + - ["", "Realm.Configuration", true, "init(deleteRealmIfMigrationNeeded:encryptionKey:fileURL:inMemoryIdentifier:migrationBlock:objectTypes:readOnly:schemaVersion:seedFilePath:shouldCompactOnLaunch:syncConfiguration:)", "", "", "Argument[encryptionKey:]", "encryption-key", "manual"] + - ["", "Realm.Configuration", true, "init(deleteRealmIfMigrationNeeded:encryptionKey:fileURL:inMemoryIdentifier:migrationBlock:objectTypes:readOnly:schemaVersion:seedFilePath:shouldCompactOnLaunch:syncConfiguration:)", "", "", "Argument[seedFilePath:]", "path-injection", "manual"] + - ["", "Realm.Configuration", true, "fileURL", "", "", "PostUpdate", "path-injection", "manual"] + - ["", "Realm.Configuration", true, "seedFilePath", "", "", "PostUpdate", "path-injection", "manual"] + - ["", "Digest", true, "md5(_:)", "", "", "Argument[0]", "weak-hash-input-MD5", "manual"] + - ["", "Digest", true, "sha1(_:)", "", "", "Argument[0]", "weak-hash-input-SHA1", "manual"] + - ["", "Digest", true, "sha2(_:variant:)", "", "", "Argument[0]", "weak-password-hash-input-SHA2", "manual"] + - ["", "Digest", true, "sha224(_:)", "", "", "Argument[0]", "weak-password-hash-input-SHA224", "manual"] + - ["", "Digest", true, "sha256(_:)", "", "", "Argument[0]", "weak-password-hash-input-SHA256", "manual"] + - ["", "Digest", true, "sha3(_:variant:)", "", "", "Argument[0]", "weak-password-hash-input-SHA3", "manual"] + - ["", "Digest", true, "sha384(_:)", "", "", "Argument[0]", "weak-password-hash-input-SHA384", "manual"] + - ["", "Digest", true, "sha512(_:)", "", "", "Argument[0]", "weak-password-hash-input-SHA512", "manual"] + - ["", "Insecure.MD5", true, "hash(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-hash-input-MD5", "manual"] + - ["", "Insecure.MD5", true, "hash(data:)", "", "", "Argument[data:]", "weak-hash-input-MD5", "manual"] + - ["", "Insecure.MD5", true, "update(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-hash-input-MD5", "manual"] + - ["", "Insecure.MD5", true, "update(data:)", "", "", "Argument[data:]", "weak-hash-input-MD5", "manual"] + - ["", "Insecure.SHA1", true, "hash(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-hash-input-SHA1", "manual"] + - ["", "Insecure.SHA1", true, "hash(data:)", "", "", "Argument[data:]", "weak-hash-input-SHA1", "manual"] + - ["", "Insecure.SHA1", true, "update(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-hash-input-SHA1", "manual"] + - ["", "Insecure.SHA1", true, "update(data:)", "", "", "Argument[data:]", "weak-hash-input-SHA1", "manual"] + - ["", "MD5", true, "callAsFunction(_:)", "", "", "Argument[0]", "weak-hash-input-MD5", "manual"] + - ["", "MD5", true, "calculate(for:)", "", "", "Argument[for:]", "weak-hash-input-MD5", "manual"] + - ["", "MD5", true, "process(block:currentHash:)", "", "", "Argument[block:]", "weak-hash-input-MD5", "manual"] + - ["", "MD5", true, "update(isLast:withBytes:)", "", "", "Argument[withBytes:]", "weak-hash-input-MD5", "manual"] + - ["", "SHA1", true, "callAsFunction(_:)", "", "", "Argument[0]", "weak-hash-input-SHA1", "manual"] + - ["", "SHA1", true, "calculate(for:)", "", "", "Argument[for:]", "weak-hash-input-SHA1", "manual"] + - ["", "SHA1", true, "process(block:currentHash:)", "", "", "Argument[block:]", "weak-hash-input-SHA1", "manual"] + - ["", "SHA1", true, "update(isLast:withBytes:)", "", "", "Argument[withBytes:]", "weak-hash-input-SHA1", "manual"] + - ["", "Logger", true, "warning(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "error(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "critical(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "debug(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "fault(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "info(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "log(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "log(_:level:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "notice(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "Logger", true, "trace(_:)", "", "", "Argument[0]", "log-injection", "manual"] + - ["", "NSException", true, "init(name:reason:userInfo:)", "", "", "Argument[reason:]", "log-injection", "manual"] + - ["", "NSException", true, "raise(_:arguments:format:)", "", "", "Argument[format:,arguments:]", "log-injection", "manual"] + - ["", "SHA256", true, "hash(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-password-hash-input-SHA256", "manual"] + - ["", "SHA256", true, "hash(data:)", "", "", "Argument[data:]", "weak-password-hash-input-SHA256", "manual"] + - ["", "SHA256", true, "update(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-password-hash-input-SHA256", "manual"] + - ["", "SHA256", true, "update(data:)", "", "", "Argument[data:]", "weak-password-hash-input-SHA256", "manual"] + - ["", "SHA2", true, "callAsFunction(_:)", "", "", "Argument[0]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA2", true, "calculate(for:)", "", "", "Argument[for:]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA2", true, "update(isLast:withBytes:)", "", "", "Argument[withBytes:]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA2", true, "process32(block:currentHash:)", "", "", "Argument[block:]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA2", true, "process64(block:currentHash:)", "", "", "Argument[block:]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA384", true, "hash(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-password-hash-input-SHA384", "manual"] + - ["", "SHA384", true, "hash(data:)", "", "", "Argument[data:]", "weak-password-hash-input-SHA384", "manual"] + - ["", "SHA384", true, "update(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-password-hash-input-SHA384", "manual"] + - ["", "SHA384", true, "update(data:)", "", "", "Argument[data:]", "weak-password-hash-input-SHA384", "manual"] + - ["", "SHA3", true, "callAsFunction(_:)", "", "", "Argument[0]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA3", true, "calculate(for:)", "", "", "Argument[for:]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA3", true, "process(block:currentHash:)", "", "", "Argument[block:]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA3", true, "update(isLast:withBytes:)", "", "", "Argument[withBytes:]", "weak-password-hash-input-SHA2", "manual"] + - ["", "SHA512", true, "hash(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-password-hash-input-SHA512", "manual"] + - ["", "SHA512", true, "hash(data:)", "", "", "Argument[data:]", "weak-password-hash-input-SHA512", "manual"] + - ["", "SHA512", true, "update(bufferPointer:)", "", "", "Argument[bufferPointer:]", "weak-password-hash-input-SHA512", "manual"] + - ["", "SHA512", true, "update(data:)", "", "", "Argument[data:]", "weak-password-hash-input-SHA512", "manual"] + - ["", "CommonTableExpression", true, "init(arguments:columns:named:recursive:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "DatabaseValueConvertible", true, "fetchAll(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "DatabaseValueConvertible", true, "fetchCursor(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "DatabaseValueConvertible", true, "fetchOne(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "DatabaseValueConvertible", true, "fetchSet(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchAll(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchCursor(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchOne(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchSet(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchAll(_:adapter:arguments:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchCursor(_:adapter:arguments:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchOne(_:adapter:arguments:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "FetchableRecord", true, "fetchSet(_:adapter:arguments:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "QueryType", true, "insert(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "update(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "insert(_:_:)", "", "", "Argument[0,1]", "database-store", "manual"] + - ["", "QueryType", true, "insert(_:or:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "insertMany(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "insertMany(_:or:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "update(_:_:)", "", "", "Argument[0,1]", "database-store", "manual"] + - ["", "QueryType", true, "update(_:or:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "upsert(_:onConflictOf:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "upsert(_:onConflictOf:setValues:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "QueryType", true, "upsert(_:onConflictOf:setValues:)", "", "", "Argument[setValues:]", "database-store", "manual"] + - ["", "Row", true, "fetchAll(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "Row", true, "fetchCursor(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "Row", true, "fetchOne(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "Row", true, "fetchSet(_:adapter:arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "SQL", true, "append(arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "SQL", true, "init(arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "SQLRequest", true, "init(adapter:arguments:cached:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "SQLStatementCursor", true, "init(arguments:database:prepFlags:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "Statement", true, "init(_:_:)", "", "", "Argument[1]", "database-store", "manual"] + - ["", "Statement", true, "scalar(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "Statement", true, "bind(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "Statement", true, "execute(arguments:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "Statement", true, "run(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "Statement", true, "setArguments(_:)", "", "", "Argument[0]", "database-store", "manual"] + - ["", "TableRecord", true, "filter(arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "TableRecord", true, "order(arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "TableRecord", true, "select(arguments:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "TableRecord", true, "select(arguments:as:sql:)", "", "", "Argument[arguments:]", "database-store", "manual"] + - ["", "ArchiveByteStream", true, "fileStream(automaticClose:fd:)", "", "", "Argument[fd:]", "path-injection", "manual"] + - ["", "ArchiveByteStream", true, "fileStream(mode:options:path:permissions:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "ArchiveByteStream", true, "withFileStream(_:automaticClose:fd:)", "", "", "Argument[fd:]", "path-injection", "manual"] + - ["", "ArchiveByteStream", true, "withFileStream(_:mode:options:path:permissions:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "Bundle", true, "init(url:)", "", "", "Argument[url:]", "path-injection", "manual"] + - ["", "Bundle", true, "init(path:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "DatabasePool", true, "init(configuration:path:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "DatabaseQueue", true, "init(configuration:path:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "DatabaseSnapshotPool", true, "init(configuration:path:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "NIOFileHandle", true, "init(path:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "NIOFileHandle", true, "init(descriptor:)", "", "", "Argument[descriptor:]", "path-injection", "manual"] + - ["", "NIOFileHandle", true, "init(flags:mode:path:)", "", "", "Argument[path:]", "path-injection", "manual"] + - ["", "NSKeyedUnarchiver", true, "unarchiveObject(withFile:)", "", "", "Argument[withFile:]", "path-injection", "manual"] + - ["", "SerializedDatabase", true, "init(configuration:defaultLabel:path:purpose:)", "", "", "Argument[path:]", "path-injection", "manual"] + - addsTo: + pack: codeql/unified-all + extensible: legacySummaryModel + data: # namespace, type, subtypes, name, signature, ext, input, output, kind, provenance + - ["", "UnsafeMutableRawPointer", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawPointer", true, "init(_:)", "", "", "Argument[0].OptionalSome.CollectionElement", "ReturnValue.OptionalSome.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawPointer", true, "init(mutating:)", "", "", "Argument[mutating:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawPointer", true, "init(mutating:)", "", "", "Argument[mutating:].OptionalSome.CollectionElement", "ReturnValue.OptionalSome.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawPointer", true, "storeBytes(as:of:toByteOffset:)", "", "", "Argument[of:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[self].CollectionElement", "Argument[2].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[2].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeMutableRawPointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[2].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "loadUnaligned(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "load(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "assumingMemoryBound(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "bindMemory(capacity:to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "alignedDown(toMultipleOf:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "alignedUp(toMultipleOf:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "alignedDown(for:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "alignedUp(for:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "moveInitializeMemory(as:count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "moveInitializeMemory(as:count:from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:count:from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:count:repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:count:repeating:)", "", "", "Argument[repeating:]", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:to:)", "", "", "Argument[to:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:to:)", "", "", "Argument[to:]", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "copyBytes(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "copyMemory(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:at:count:to:)", "", "", "Argument[to:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawPointer", true, "initializeMemory(as:at:count:to:)", "", "", "Argument[to:]", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsignedInteger", true, "init(exactly:)", "", "", "Argument[exactly:]", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "UnsignedInteger", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(littleEndian:)", "", "", "Argument[littleEndian:]", "ReturnValue", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(bigEndian:)", "", "", "Argument[bigEndian:]", "ReturnValue", "taint", "manual"] + - ["", "FixedWidthInteger", true, "dividingFullWidth(_:)", "", "", "Argument[self]", "ReturnValue.TupleElement[0,1]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "dividingFullWidth(_:)", "", "", "Argument[1].TupleElement[0,1]", "ReturnValue.TupleElement[0,1]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "multipliedFullWidth(by:)", "", "", "Argument[self,by:]", "ReturnValue.TupleElement[0,1]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "FixedWidthInteger", true, "remainderReportingOverflow(dividingBy:)", "", "", "Argument[self,dividingBy:]", "ReturnValue.TupleElement[0]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "dividedReportingOverflow(by:)", "", "", "Argument[self,by:]", "ReturnValue.TupleElement[0]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "multipliedReportingOverflow(by:)", "", "", "Argument[self,by:]", "ReturnValue.TupleElement[0]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "subtractingReportingOverflow(_:)", "", "", "Argument[self,0]", "ReturnValue.TupleElement[0]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "addingReportingOverflow(_:)", "", "", "Argument[self,0]", "ReturnValue.TupleElement[0]", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(bitPattern:)", "", "", "Argument[bitPattern:]", "ReturnValue", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(clamping:)", "", "", "Argument[clamping:]", "ReturnValue", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(truncatingIfNeeded:)", "", "", "Argument[truncatingIfNeeded:]", "ReturnValue", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(_:radix:)", "", "", "Argument[0]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "FixedWidthInteger", true, "init(truncating:)", "", "", "Argument[truncating:]", "ReturnValue", "taint", "manual"] + - ["", "Numeric", true, "init(exactly:)", "", "", "Argument[exactly:]", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "Numeric", true, "init(bitPattern:)", "", "", "Argument[bitPattern:]", "ReturnValue", "taint", "manual"] + - ["", "Numeric", true, "init(truncating:)", "", "", "Argument[truncating:]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "quotientAndRemainder(dividingBy:)", "", "", "Argument[self,dividingBy:]", "ReturnValue.TupleElement[0,1]", "taint", "manual"] + - ["", "BinaryInteger", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "init(clamping:)", "", "", "Argument[clamping:]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "init(truncatingIfNeeded:)", "", "", "Argument[truncatingIfNeeded:]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "advanced(by:)", "", "", "Argument[self,by:]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "distance(to:)", "", "", "Argument[self,to:]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "formatted()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "formatted(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "init(_:format:lenient:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "BinaryInteger", true, "init(_:strategy:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "withContiguousStorageIfAvailable(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Sequence", true, "withContiguousStorageIfAvailable(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "value", "manual"] + - ["", "Sequence", true, "withContiguousStorageIfAvailable(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "Sequence", true, "makeIterator()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "suffix(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "suffix(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "dropLast(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "dropLast(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "split(maxSplits:omittingEmptySubsequences:whereSeparator:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "split(maxSplits:omittingEmptySubsequences:whereSeparator:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "prefix(while:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "prefix(while:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "prefix(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "prefix(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "drop(while:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "drop(while:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "dropFirst(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "dropFirst(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "split(maxSplits:omittingEmptySubsequences:separator:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "split(maxSplits:omittingEmptySubsequences:separator:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "shuffled()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "shuffled()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "shuffled(using:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "shuffled(using:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "forEach(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0]", "value", "manual"] + - ["", "Sequence", true, "joined()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "joined()", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "joined()", "", "", "Argument[self].CollectionElement.CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "joined(separator:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "joined(separator:)", "", "", "Argument[self].CollectionElement.CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "joined(separator:)", "", "", "Argument[separator:,self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "reversed()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "reversed()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "first(where:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "Sequence", true, "enumerated()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement.TupleElement[1]", "value", "manual"] + - ["", "Sequence", true, "max(by:)", "", "", "Argument[self].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "Sequence", true, "min(by:)", "", "", "Argument[self].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "Sequence", true, "max()", "", "", "Argument[self].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "Sequence", true, "min()", "", "", "Argument[self].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "Sequence", true, "sorted()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "sorted()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "sorted(by:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Sequence", true, "sorted(by:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Sequence", true, "formatted()", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeBufferPointer", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeBufferPointer", true, "init(count:start:)", "", "", "Argument[start:].OptionalSome.CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[self].CollectionElement", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeBufferPointer", true, "init(rebasing:)", "", "", "Argument[rebasing:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafePointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[self].CollectionElement", "Argument[2].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafePointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[2].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "init(_:)", "", "", "Argument[0].OptionalSome.CollectionElement", "ReturnValue.OptionalSome.CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "init(mutating:)", "", "", "Argument[mutating:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "init(mutating:)", "", "", "Argument[mutating:].OptionalSome.CollectionElement", "ReturnValue.OptionalSome.CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[self].CollectionElement", "Argument[2].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutablePointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[2].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[2].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutablePointer", true, "initialize(count:repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "initialize(to:)", "", "", "Argument[to:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "move()", "", "", "Argument[self].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "assign(count:repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "update(count:repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "assign(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "update(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "moveInitialize(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "initialize(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "moveUpdate(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "moveAssign(count:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "initialize(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutablePointer", true, "initialize(count:to:)", "", "", "Argument[to:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "init(count:start:)", "", "", "Argument[start:].OptionalSome.CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "init(mutating:)", "", "", "Argument[mutating:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "update(repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[self].CollectionElement", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "moveElement(from:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "initializeElement(at:to:)", "", "", "Argument[to:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "moveUpdate(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "moveInitialize(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "update(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "update(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "update(from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.TupleElement[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "initialize(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "initialize(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "initialize(from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.TupleElement[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "initialize(repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "init(rebasing:)", "", "", "Argument[rebasing:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableBufferPointer", true, "assign(repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "value", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "ContiguousArray", true, "withUnsafeBufferPointer(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "ContiguousArray", true, "withUnsafeBufferPointer(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "value", "manual"] + - ["", "ContiguousArray", true, "withUnsafeBufferPointer(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "ContiguousArray", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "Collection", true, "makeIterator()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "removeFirst()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "suffix(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "suffix(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "dropLast(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "dropLast(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "randomElement()", "", "", "Argument[self].CollectionElement", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "Collection", true, "randomElement(using:)", "", "", "Argument[self].CollectionElement", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "Collection", true, "popFirst()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "split(maxSplits:omittingEmptySubsequences:whereSeparator:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "prefix(through:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "prefix(through:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "suffix(from:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "prefix(upTo:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "prefix(upTo:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "prefix(while:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "prefix(while:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "prefix(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "prefix(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "dropFirst(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "dropFirst(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "split(maxSplits:omittingEmptySubsequences:separator:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "flatMap(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "flatMap(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "trimmingPrefix(while:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "trimmingPrefix(while:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Collection", true, "trimmingPrefix(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Collection", true, "trimmingPrefix(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeRawPointer", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeRawPointer", true, "init(_:)", "", "", "Argument[0].OptionalSome.CollectionElement", "ReturnValue.OptionalSome.CollectionElement", "value", "manual"] + - ["", "UnsafeRawPointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[self].CollectionElement", "Argument[2].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "withMemoryRebound(_:capacity:to:)", "", "", "Argument[2].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeRawPointer", true, "loadUnaligned(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "load(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "assumingMemoryBound(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "bindMemory(capacity:to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "alignedDown(toMultipleOf:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "alignedUp(toMultipleOf:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "alignedDown(for:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawPointer", true, "alignedUp(for:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Slice", true, "init(base:bounds:)", "", "", "Argument[base:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Slice", true, "remove(at:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "Slice", true, "insert(_:at:)", "", "", "Argument[0]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "insert(at:contentsOf:)", "", "", "Argument[contentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "replaceSubrange(_:with:)", "", "", "Argument[with:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "storeBytes(as:of:toByteOffset:)", "", "", "Argument[of:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "update(repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "loadUnaligned(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "Slice", true, "load(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "Slice", true, "assumingMemoryBound(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Slice", true, "withMemoryRebound(_:to:)", "", "", "Argument[self].CollectionElement", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "Slice", true, "bindMemory(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Slice", true, "moveInitializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "moveInitializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initializeMemory(as:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initializeMemory(as:from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.TupleElement[0,1].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initializeMemory(as:repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initializeMemory(as:repeating:)", "", "", "Argument[repeating:]", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Slice", true, "copyBytes(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "moveElement(from:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "Slice", true, "initializeElement(at:to:)", "", "", "Argument[to:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "moveUpdate(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "moveInitialize(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "update(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "update(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "update(from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.TupleElement[0].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initialize(fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initialize(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initialize(from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.TupleElement[0,1].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "initialize(repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Slice", true, "withContiguousMutableStorageIfAvailable(_:to:)", "", "", "Argument[self].CollectionElement", "Argument[to:].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "withContiguousMutableStorageIfAvailable(_:to:)", "", "", "Argument[to:].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Slice", true, "withContiguousMutableStorageIfAvailable(_:to:)", "", "", "Argument[to:].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "SignedInteger", true, "init(exactly:)", "", "", "Argument[exactly:]", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "SignedInteger", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "popLast()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "suffix(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "suffix(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "BidirectionalCollection", true, "dropLast(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "dropLast(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "BidirectionalCollection", true, "suffix(from:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "last(where:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "joined(separator:)", "", "", "Argument[self,separator:]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "joined(separator:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "joined(separator:)", "", "", "Argument[self].CollectionElement.CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "BidirectionalCollection", true, "reversed()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BidirectionalCollection", true, "reversed()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "String", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(_:)", "", "", "Argument[0]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(count:repeating:)", "", "", "Argument[repeating:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "insert(at:contentsOf:)", "", "", "Argument[contentsOf:]", "Argument[self]", "taint", "manual"] + - ["", "String", true, "init(extendedGraphemeClusterLiteral:)", "", "", "Argument[extendedGraphemeClusterLiteral:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(unicodeScalarLiteral:)", "", "", "Argument[unicodeScalarLiteral:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "encode(to:)", "", "", "Argument[self]", "Argument[to:]", "taint", "manual"] + - ["", "String", true, "init(from:)", "", "", "Argument[from:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(from:)", "", "", "Argument[from:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "randomElement()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "randomElement(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "split(maxSplits:omittingEmptySubsequences:whereSeparator:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(stringLiteral:)", "", "", "Argument[stringLiteral:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(stringInterpolation:)", "", "", "Argument[stringInterpolation:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "decodeCString(_:as:repairingInvalidCodeUnits:)", "", "", "Argument[0]", "ReturnValue.TupleElement[0]", "taint", "manual"] + - ["", "String", true, "decodeCString(_:as:repairingInvalidCodeUnits:)", "", "", "Argument[0].CollectionElement", "ReturnValue.TupleElement[0]", "taint", "manual"] + - ["", "String", true, "init(validatingUTF8:)", "", "", "Argument[validatingUTF8:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(validatingUTF8:)", "", "", "Argument[validatingUTF8:].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "enumerated()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "max(by:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "min(by:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "max()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "min()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "withUTF8(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "String", true, "withUTF8(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self]", "taint", "manual"] + - ["", "String", true, "withUTF8(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "String", true, "init(initializingUTF8With:unsafeUninitializedCapacity:)", "", "", "Argument[initializingUTF8With:].Parameter[0].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(_:radix:uppercase:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(validating:)", "", "", "Argument[validating:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(describing:)", "", "", "Argument[describing:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(contentsOf:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(contentsOfFile:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(contentsOf:encoding:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(contentsOfFile:encoding:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(contentsOfFile:usedEncoding:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(platformString:)", "", "", "Argument[platformString:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(platformString:)", "", "", "Argument[platformString:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "withPlatformString(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "String", true, "withPlatformString(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "String", true, "init(bytesNoCopy:encoding:freeWhenDone:length:)", "", "", "Argument[bytesNoCopy:].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(cString:encoding:)", "", "", "Argument[cString:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(cString:encoding:)", "", "", "Argument[cString:].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(data:encoding:)", "", "", "Argument[data:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(_:format:)", "", "", "Argument[format:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(_:format:)", "", "", "Argument[1].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(arguments:format:)", "", "", "Argument[format:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(arguments:format:)", "", "", "Argument[arguments:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(_:format:locale:)", "", "", "Argument[format:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(_:format:locale:)", "", "", "Argument[2].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(arguments:format:locale:)", "", "", "Argument[format:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(arguments:format:locale:)", "", "", "Argument[arguments:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(utf8String:)", "", "", "Argument[utf8String:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(utf8String:)", "", "", "Argument[utf8String:].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "localizedStringWithFormat(_:_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "localizedStringWithFormat(_:_:)", "", "", "Argument[1].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(bytes:encoding:)", "", "", "Argument[bytes:].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(contendsOf:usedEncoding:)", "", "", "Argument[contendsOf:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(decoding:)", "", "", "Argument[decoding:]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(count:utf16CodeUnits:)", "", "", "Argument[utf16CodeUnits:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(count:freeWhenDone:utf16CodeUnitsNoCopy:)", "", "", "Argument[utf16CodeUnitsNoCopy:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "String", true, "init(validatingPlatformString:)", "", "", "Argument[validatingPlatformString:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "init(validatingPlatformString:)", "", "", "Argument[validatingPlatformString:].CollectionElement", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "String", true, "subscript(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "String", true, "withMutableCharacters(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0]", "value", "manual"] + - ["", "String", true, "withMutableCharacters(_:)", "", "", "Argument[0].Parameter[0]", "Argument[self]", "value", "manual"] + - ["", "String", true, "withMutableCharacters(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self]", "taint", "manual"] + - ["", "String", true, "withMutableCharacters(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "BinaryFloatingPoint", true, "init(exponentBitPattern:sign:significandBitPattern:)", "", "", "Argument[sign:,exponentBitPattern:,significandBitPattern:]", "ReturnValue", "taint", "manual"] + - ["", "BinaryFloatingPoint", true, "formatted()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BinaryFloatingPoint", true, "formatted(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "BinaryFloatingPoint", true, "init(_:format:lenient:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "BinaryFloatingPoint", true, "init(_:strategy:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "UnsafeRawBufferPointer", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeRawBufferPointer", true, "init(count:start:)", "", "", "Argument[start:].OptionalSome.CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawBufferPointer", true, "loadUnaligned(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeRawBufferPointer", true, "load(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeRawBufferPointer", true, "assumingMemoryBound(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[self].CollectionElement", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeRawBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeRawBufferPointer", true, "bindMemory(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeRawBufferPointer", true, "init(rebasing:)", "", "", "Argument[rebasing:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Array", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Array", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "value", "manual"] + - ["", "Array", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Array", true, "withUnsafeMutableBufferPointer(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "Array", true, "withUnsafeBufferPointer(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Array", true, "withUnsafeBufferPointer(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "value", "manual"] + - ["", "Array", true, "withUnsafeBufferPointer(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "Array", true, "makeIterator()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Array", true, "insert(_:at:)", "", "", "Argument[0]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Array", true, "insert(_:at:)", "", "", "Argument[at:]", "Argument[self]", "taint", "manual"] + - ["", "Array", true, "init(arrayLiteral:)", "", "", "Argument[arrayLiteral:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Array", true, "withUnsafeBytes(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Array", true, "withUnsafeBytes(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Array", true, "withUnsafeBytes(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "Array", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Array", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Array", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Array", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "MutableCollection", true, "withContiguousMutableStorageIfAvailable(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "MutableCollection", true, "withContiguousMutableStorageIfAvailable(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "value", "manual"] + - ["", "MutableCollection", true, "withContiguousMutableStorageIfAvailable(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "MutableCollection", true, "withContiguousMutableStorageIfAvailable(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "RangeReplaceableCollection", true, "init(_:)", "", "", "Argument[0]", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "RangeReplaceableCollection", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "RangeReplaceableCollection", true, "append(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "RangeReplaceableCollection", true, "remove(at:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "RangeReplaceableCollection", true, "insert(_:at:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "RangeReplaceableCollection", true, "append(contentsOf:)", "", "", "Argument[contentsOf:]", "Argument[self]", "taint", "manual"] + - ["", "RangeReplaceableCollection", true, "init(count:repeating:)", "", "", "Argument[repeating:]", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "RangeReplaceableCollection", true, "removeFirst()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "RangeReplaceableCollection", true, "replaceSubrange(_:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "RangeReplaceableCollection", true, "replaceSubrange(_:with:)", "", "", "Argument[with:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "RangeReplaceableCollection", true, "removeLast()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "IteratorProtocol", true, "next()", "", "", "Argument[self].CollectionElement", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "init(count:start:)", "", "", "Argument[start:].OptionalSome.CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "init(mutating:)", "", "", "Argument[mutating:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "storeBytes(as:of:toByteOffset:)", "", "", "Argument[of:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "loadUnaligned(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "load(as:fromByteOffset:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "assumingMemoryBound(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[self].CollectionElement", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "withMemoryRebound(_:to:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "bindMemory(to:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "moveInitializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "moveInitializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "initializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "initializeMemory(as:fromContentsOf:)", "", "", "Argument[fromContentsOf:].CollectionElement", "ReturnValue.TupleElement[0,1].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "initializeMemory(as:from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "initializeMemory(as:from:)", "", "", "Argument[from:].CollectionElement", "ReturnValue.TupleElement[0,1].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "initializeMemory(as:repeating:)", "", "", "Argument[repeating:]", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "initializeMemory(as:repeating:)", "", "", "Argument[repeating:]", "ReturnValue.TupleElement[0,1].CollectionElement", "taint", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "copyBytes(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "init(rebasing:)", "", "", "Argument[rebasing:].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "UnsafeMutableRawBufferPointer", true, "copyMemory(from:)", "", "", "Argument[from:].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "LosslessStringConvertible", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "RawRepresentable", true, "init(rawValue:)", "", "", "Argument[rawValue:]", "ReturnValue", "taint", "manual"] + - ["", "Dictionary", true, "makeIterator()", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Dictionary", true, "updateValue(_:forKey:)", "", "", "Argument[0]", "Argument[self].CollectionElement.TupleElement[1]", "value", "manual"] + - ["", "Dictionary", true, "updateValue(_:forKey:)", "", "", "Argument[forKey:]", "Argument[self].CollectionElement.TupleElement[0]", "value", "manual"] + - ["", "Dictionary", true, "updateValue(_:forKey:)", "", "", "Argument[self].CollectionElement.TupleElement[1]", "ReturnValue.OptionalSome", "value", "manual"] + - ["", "Set", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "Set", true, "init(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Set", true, "remove(at:)", "", "", "Argument[self].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "Set", true, "removeFirst()", "", "", "Argument[self].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "Set", true, "filter(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Set", true, "insert(_:)", "", "", "Argument[0]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Set", true, "insert(_:)", "", "", "Argument[0]", "ReturnValue.TupleElement[1]", "taint", "manual"] + - ["", "Set", true, "intersection(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Set", true, "subtracting(_:)", "", "", "Argument[self].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Set", true, "symmetricDifference(_:)", "", "", "Argument[self,0].CollectionElement", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "Set", true, "union(_:)", "", "", "Argument[self,0].CollectionElement", "ReturnValue.CollectionElement", "value", "manual"] + - ["", "Set", true, "update(with:)", "", "", "Argument[with:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "Set", true, "update(with:)", "", "", "Argument[with:]", "Argument[self].CollectionElement", "value", "manual"] + - ["", "Set", true, "remove(_:)", "", "", "Argument[0]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "Set", true, "formSymmetricDifference(_:)", "", "", "Argument[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Set", true, "formUnion(_:)", "", "", "Argument[0].CollectionElement", "Argument[self].CollectionElement", "value", "manual"] + - ["", "TextOutputStreamable", true, "write(to:)", "", "", "Argument[self]", "Argument[to:]", "taint", "manual"] + - ["", "TextOutputStream", true, "write(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "Substring", true, "withUTF8(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Substring", true, "withUTF8(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self]", "taint", "manual"] + - ["", "Substring", true, "withUTF8(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "StringProtocol", true, "withCString(_:encodedAs:)", "", "", "Argument[self]", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "StringProtocol", true, "withCString(_:encodedAs:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "StringProtocol", true, "withCString(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "StringProtocol", true, "withCString(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "StringProtocol", true, "init(as:decodingCString:)", "", "", "Argument[decodingCString:].OptionalSome.CollectionElement", "ReturnValue.OptionalSome.TupleElement[0]", "taint", "manual"] + - ["", "StringProtocol", true, "init(cString:)", "", "", "Argument[cString:]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "init(cString:)", "", "", "Argument[cString:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "init(as:decoding:)", "", "", "Argument[decoding:]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "uppercased()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "lowercased()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "getBytes(_:encoding:maxLength:options:range:remaining:usedLength:)", "", "", "Argument[self]", "Argument[0].CollectionElement", "taint", "manual"] + - ["", "StringProtocol", true, "getCString(_:encoding:maxLength:)", "", "", "Argument[self]", "Argument[0].CollectionElement", "taint", "manual"] + - ["", "StringProtocol", true, "appending(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "addingPercentEscapes(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "appendingFormat(_:_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "appendingFormat(_:_:)", "", "", "Argument[1].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "applyingTransform(_:reverse:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "cString(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "capitalized(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "completePath(caseSensitive:filterTypes:into:matchesInto:)", "", "", "Argument[self]", "Argument[into:].CollectionElement", "taint", "manual"] + - ["", "StringProtocol", true, "completePath(caseSensitive:filterTypes:into:matchesInto:)", "", "", "Argument[self]", "Argument[matchesInto:].CollectionElement.CollectionElement", "taint", "manual"] + - ["", "StringProtocol", true, "components(separatedBy:)", "", "", "Argument[self]", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "StringProtocol", true, "data(allowLossyConversion:using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "folding(locale:options:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "lowercased(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "padding(startingAt:toLength:withPad:)", "", "", "Argument[withPad:]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "padding(startingAt:toLength:withPad:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "propertyList()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "propertyListFromStringsFileFormat()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "replacingCharacters(in:with:)", "", "", "Argument[with:]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "replacingCharacters(in:with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "replacingOccurrences(of:options:range:with:)", "", "", "Argument[with:]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "replacingOccurrences(of:options:range:with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "replacingPercentEscapes(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "substring(from:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "substring(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "trimmingCharacters(in:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "uppercased(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "StringProtocol", true, "addingPercentEncoding(withAllowedCharacter:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Strideable", true, "advanced(by:)", "", "", "Argument[self,by:]", "ReturnValue", "taint", "manual"] + - ["", "Strideable", true, "distance(to:)", "", "", "Argument[self,to:]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "rounded(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "maximumMagnitude(_:_:)", "", "", "Argument[0,1]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "minimumMagnitude(_:_:)", "", "", "Argument[0,1]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "maximum(_:_:)", "", "", "Argument[0,1]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "minimum(_:_:)", "", "", "Argument[0,1]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "addProduct(_:_:)", "", "", "Argument[self,0,1]", "Argument[self]", "taint", "manual"] + - ["", "FloatingPoint", true, "addingProduct(_:_:)", "", "", "Argument[self,0,1]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "squareRoot()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "formTruncatingRemainder(dividingBy:)", "", "", "Argument[self,dividingBy:]", "Argument[self]", "taint", "manual"] + - ["", "FloatingPoint", true, "truncatingRemainder(dividingBy:)", "", "", "Argument[self,dividingBy:]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "formRemainder(dividingBy:)", "", "", "Argument[self,dividingBy:]", "Argument[self]", "taint", "manual"] + - ["", "FloatingPoint", true, "remainder(dividingBy:)", "", "", "Argument[self,dividingBy:]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "init(magnitudeOf:signOf:)", "", "", "Argument[magnitudeOf:]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "init(exponent:sign:significand:)", "", "", "Argument[exponent:,significand:]", "ReturnValue", "taint", "manual"] + - ["", "FloatingPoint", true, "rounded()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "OptionSet", true, "init(rawValue:)", "", "", "Argument[rawValue:]", "ReturnValue", "taint", "manual"] + - ["", "", false, "min(_:_:)", "", "", "Argument[0,1]", "ReturnValue", "taint", "manual"] + - ["", "", false, "min(_:_:_:_:)", "", "", "Argument[0,1,2]", "ReturnValue", "taint", "manual"] + - ["", "", false, "min(_:_:_:_:)", "", "", "Argument[3].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "", false, "max(_:_:)", "", "", "Argument[0,1]", "ReturnValue", "taint", "manual"] + - ["", "", false, "max(_:_:_:_:)", "", "", "Argument[0,1,2]", "ReturnValue", "taint", "manual"] + - ["", "", false, "max(_:_:_:_:)", "", "", "Argument[3].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "", false, "unsafeBitCast(_:to:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "", false, "unsafeDowncast(_:to:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "", false, "dump(_:indent:maxDepth:maxItems:name:to:)", "", "", "Argument[0,name:]", "Argument[to:]", "taint", "manual"] + - ["", "", false, "abs(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "", false, "numericCast(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "", false, "withExtendedLifetime(_:_:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "", false, "withUnsafeMutablePointer(_:to:)", "", "", "Argument[to:]", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "", false, "withUnsafeMutablePointer(_:to:)", "", "", "Argument[1].Parameter[0].CollectionElement", "Argument[to:]", "value", "manual"] + - ["", "", false, "withUnsafeMutablePointer(_:to:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "", false, "withUnsafePointer(_:to:)", "", "", "Argument[to:]", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "", false, "withUnsafePointer(_:to:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "", false, "swap(_:_:)", "", "", "Argument[0]", "Argument[1]", "value", "manual"] + - ["", "", false, "swap(_:_:)", "", "", "Argument[1]", "Argument[0]", "value", "manual"] + - ["", "", false, "print(_:separator:terminator:to:)", "", "", "Argument[0].CollectionElement", "Argument[to:]", "taint", "manual"] + - ["", "", false, "print(_:separator:terminator:to:)", "", "", "Argument[separator:,terminator:]", "Argument[to:]", "taint", "manual"] + - ["", "", false, "debugPrint(_:separator:terminator:to:)", "", "", "Argument[0].CollectionElement", "Argument[to:]", "taint", "manual"] + - ["", "", false, "debugPrint(_:separator:terminator:to:)", "", "", "Argument[separator:,terminator:]", "Argument[to:]", "taint", "manual"] + - ["", "", false, "withUnsafeTemporaryAllocation(_:alignment:byteCount:)", "", "", "Argument[2].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "", false, "withUnsafeTemporaryAllocation(_:capacity:of:)", "", "", "Argument[2].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "", false, "withVaList(_:_:)", "", "", "Argument[0]", "Argument[1].Parameter[0]", "value", "manual"] + - ["", "", false, "getVaList(_:)", "", "", "Argument[0].CollectionElement", "ReturnValue", "value", "manual"] + - ["", "", false, "withUnsafeMutableBytes(_:of:)", "", "", "Argument[of:]", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "", false, "withUnsafeMutableBytes(_:of:)", "", "", "Argument[1].Parameter[0].CollectionElement", "Argument[of:]", "taint", "manual"] + - ["", "", false, "withUnsafeMutableBytes(_:of:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "", false, "withUnsafeBytes(_:of:)", "", "", "Argument[of:]", "Argument[1].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "", false, "withUnsafeBytes(_:of:)", "", "", "Argument[1].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "", false, "<-(_:_:)", "", "", "Argument[0,1]", "ReturnValue", "taint", "manual"] + - ["", "", false, "JSStringRetain(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "", false, "JSStringCreateWithUTF8CString(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "", false, "JSStringCreateWithCharacters(_:_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(_:)", "", "", "Argument[0]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "init(fileReferenceLiteralResourceName:)", "", "", "Argument[fileReferenceLiteralResourceName:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(string:)", "(String)", "", "Argument[string:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "appendingPathExtension(for:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "appendingPathComponent(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "appendingPathExtension(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "appendingPathComponent(_:isDirectory:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "appendingPathComponent(_:conformingTo:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "formatted()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "formatted(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(_:strategy:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "append(component:directoryHint:)", "", "", "Argument[self,component:]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "append(components:directoryHint:)", "", "", "Argument[self,components:]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "append(directoryHint:path:)", "", "", "Argument[self,path:]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "append(queryItems:)", "", "", "Argument[self,queryItems:]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "appendPathComponent(_:)", "", "", "Argument[self,0]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "appendPathComponent(_:conformingTo:)", "", "", "Argument[self,0]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "appendPathComponent(_:isDirectory:)", "", "", "Argument[self,0]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "appendPathExtension(_:)", "", "", "Argument[self,0]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "appending(component:directoryHint:)", "", "", "Argument[self,component:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "appending(components:directoryHint:)", "", "", "Argument[self,components:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "appending(directoryHint:path:)", "", "", "Argument[self,path:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "appending(queryItems:)", "", "", "Argument[self,queryItems:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "bookmarkData(includingResourceValuesForKeys:options:relativeTo:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "bookmarkData(includingResourceValuesForKeys:options:relativeTo:)", "", "", "Argument[includingResourceValuesForKeys:].OptionalSome.CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "bookmarkData(includingResourceValuesForKeys:options:relativeTo:)", "", "", "Argument[relativeTo:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "bookmarkData(withContentsOf:)", "", "", "Argument[withContentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "deletingLastPathComponent()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "deletingPathExtension()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "fragment(percentEncoded:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "homeDirectory(forUser:)", "", "", "Argument[forUser:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "host(percentEncoded:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(_:isDirectory:)", "", "", "Argument[0]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "init(dataRepresentation:isAbsolute:relativeTo:)", "", "", "Argument[dataRepresentation:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(dataRepresentation:isAbsolute:relativeTo:)", "", "", "Argument[relativeTo:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(filePath:)", "", "", "Argument[filePath:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "init(directoryHint:filePath:)", "", "", "Argument[filePath:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "init(directoryHint:filePath:relativeTo:)", "", "", "Argument[filePath:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(directoryHint:filePath:relativeTo:)", "", "", "Argument[relativeTo:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(filePath:isDirectory:)", "", "", "Argument[filePath:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithFileSystemRepresentation:isDirectory:relativeTo:)", "", "", "Argument[fileURLWithFileSystemRepresentation:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithFileSystemRepresentation:isDirectory:relativeTo:)", "", "", "Argument[relativeTo:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithPath:)", "", "", "Argument[fileURLWithPath:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithPath:isDirectory:)", "", "", "Argument[fileURLWithPath:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithPath:isDirectory:relativeTo:)", "", "", "Argument[fileURLWithPath:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithPath:isDirectory:relativeTo:)", "", "", "Argument[relativeTo:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithPath:relativeTo:)", "", "", "Argument[fileURLWithPath:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(fileURLWithPath:relativeTo:)", "", "", "Argument[relativeTo:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(appropriateFor:create:for:in:)", "", "", "Argument[for:,in:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(appropriateFor:create:for:in:)", "", "", "Argument[appropriateFor:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(options:resolvingAliasFileAt:)", "", "", "Argument[resolvingAliasFileAt:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(bookmarkDataIsStale:options:relativeTo:resolvingBookmarkData:)", "", "", "Argument[resolvingBookmarkData:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(bookmarkDataIsStale:options:relativeTo:resolvingBookmarkData:)", "", "", "Argument[relativeTo:].OptionalSome", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(resource:)", "", "", "Argument[resource:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "init(encodingInvalidCharacters:string:)", "", "", "Argument[string:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "init(relativeTo:string:)", "(String,URL?)", "", "Argument[string:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "init(relativeTo:string:)", "(String,URL?)", "", "Argument[relativeTo:].OptionalSome", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "URL", true, "password(percentEncoded:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "path(percentEncoded:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "promisedItemResourceValues(forKeys:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "query(percentEncoded:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "resolvingSymlinksInPath()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "resourceValues(forKeys:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "resourceValues(forKeys:fromBookmarkData:)", "", "", "Argument[fromBookmarkData:]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "setResourceValues(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "setTemporaryResourceValue(_:forKey:)", "", "", "Argument[self,0]", "Argument[self]", "taint", "manual"] + - ["", "URL", true, "user(percentEncoded:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URL", true, "withUnsafeFileSystemRepresentation(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].OptionalSome.CollectionElement", "taint", "manual"] + - ["", "URL", true, "withUnsafeFileSystemRepresentation(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(contentsOf:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(contentsOfFile:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(contentsOf:options:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(data:)", "", "", "Argument[data:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(bytes:length:)", "", "", "Argument[bytes:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "base64EncodedData(options:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "base64EncodedString(options:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "base64Encoding()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "compressed(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "dataWithContentsOfMappedFile(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "decompressed(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "enumerateBytes(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0]", "taint", "manual"] + - ["", "NSData", true, "getBytes(_:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSData", true, "getBytes(_:length:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSData", true, "getBytes(_:range:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSData", true, "init(base64Encoded:options:)", "", "", "Argument[base64Encoded:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(base64Encoding:)", "", "", "Argument[base64Encoding:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(bytesNoCopy:length:)", "", "", "Argument[bytesNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(bytesNoCopy:deallocator:length:)", "", "", "Argument[bytesNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(bytesNoCopy:freeWhenDone:length:)", "", "", "Argument[bytesNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(contentsOfFile:options:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "init(contentsOfMappedFile:)", "", "", "Argument[contentsOfMappedFile:]", "ReturnValue", "taint", "manual"] + - ["", "NSData", true, "subdata(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(coder:)", "", "", "Argument[coder:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(cString:)", "", "", "Argument[cString:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "getBytes(_:encoding:maxLength:options:range:remaining:usedLength:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "getCharacters(_:range:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "character(at:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "getCString(_:encoding:maxLength:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "init(string:)", "", "", "Argument[string:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "appending(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(contentsOf:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(contentsOfFile:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "string(withContentsOf:)", "", "", "Argument[withContentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(contentsOf:encoding:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "string(withContentsOfFile:)", "", "", "Argument[withContentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(contentsOfFile:encoding:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(contentsOf:usedEncoding:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(contentsOfFile:usedEncoding:)", "", "", "Argument[contentsOfFile:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "appendingPathComponent(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "appendingPathExtension(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "appendingPathComponent(_:conformingTo:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "addingPercentEncoding(withAllowedCharacters:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "addingPercentEscapes(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "appendingFormat(_:_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "appendingFormat(_:_:)", "", "", "Argument[1].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "applyTransform(_:range:reverse:updatedRange:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "applyingTransform(_:reverse:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "cString()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "cString(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "capitalized(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "completePath(caseSensitive:filterTypes:into:matchesInto:)", "", "", "Argument[self]", "Argument[into:].CollectionElement", "taint", "manual"] + - ["", "NSString", true, "completePath(caseSensitive:filterTypes:into:matchesInto:)", "", "", "Argument[self]", "Argument[matchesInto:].CollectionElement.CollectionElement", "taint", "manual"] + - ["", "NSString", true, "components(separatedBy:)", "", "", "Argument[self]", "ReturnValue.CollectionElement", "taint", "manual"] + - ["", "NSString", true, "data(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "data(allowLossyConversion:using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "enumerateLines(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0]", "taint", "manual"] + - ["", "NSString", true, "enumerateLinguisticTags(in:options:orthography:scheme:using:)", "", "", "Argument[self]", "Argument[using:].Parameter[0].OptionalSome", "taint", "manual"] + - ["", "NSString", true, "enumerateSubstrings(in:options:using:)", "", "", "Argument[self]", "Argument[using:].Parameter[0].OptionalSome", "taint", "manual"] + - ["", "NSString", true, "enumerateSubstrings(in:options:using:)", "", "", "Argument[using:].Parameter[0].OptionalSome", "Argument[self]", "taint", "manual"] + - ["", "NSString", true, "folding(locale:options:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "getCString(_:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "getCString(_:maxLength:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "getCString(_:maxLength:range:remaining:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "getCharacters(_:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "getFileSystemRepresentation(_:maxLength:)", "", "", "Argument[self]", "Argument[0]", "taint", "manual"] + - ["", "NSString", true, "init(bytes:encoding:length:)", "", "", "Argument[bytes:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(bytesNoCopy:deallocator:encoding:length:)", "", "", "Argument[bytesNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(bytesNoCopy:encoding:freeWhenDone:length:)", "", "", "Argument[bytesNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(cString:encoding:)", "", "", "Argument[cString:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(cString:length:)", "", "", "Argument[cString:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(cStringNoCopy:freeWhenDone:length:)", "", "", "Argument[cStringNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(characters:length:)", "", "", "Argument[characters:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(charactersNoCopy:dellocator:length:)", "", "", "Argument[charactersNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(charactersNoCopy:freeWhenDone:length:)", "", "", "Argument[charactersNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(data:encoding:)", "", "", "Argument[data:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(_:format:)", "", "", "Argument[format:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(_:format:)", "", "", "Argument[1].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(arguments:format:)", "", "", "Argument[format:,arguments:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(_:format:locale:)", "", "", "Argument[format:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(_:format:locale:)", "", "", "Argument[2].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(arguments:format:locale:)", "", "", "Argument[format:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(arguments:format:locale:)", "", "", "Argument[arguments:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "init(utf8String:)", "", "", "Argument[utf8String:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "localizedStringWithFormat(_:_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "localizedStringWithFormat(_:_:)", "", "", "Argument[1].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "lossyCString()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "lowercased(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "padding(startingAt:toLength:withPad:)", "", "", "Argument[withPad:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "padding(startingAt:toLength:withPad:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "path(withComponents:)", "", "", "Argument[withComponents:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "propertyList()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "propertyListFromStringsFileFormat()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "replacingCharacters(in:with:)", "", "", "Argument[with:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "replacingCharacters(in:with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "replacingOccurrences(of:with:)", "", "", "Argument[with:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "replacingOccurrences(of:with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "replacingOccurrences(of:options:range:with:)", "", "", "Argument[with:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "replacingOccurrences(of:options:range:with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "replacingPercentEscapes(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "string(withCString:)", "", "", "Argument[withCString:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "string(length:withCString:)", "", "", "Argument[withCString:]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "stringEncoding(convertedString:encodingOptions:for:usedLossyCompression:)", "", "", "Argument[for:]", "Argument[convertedString:]", "taint", "manual"] + - ["", "NSString", true, "strings(byAppendingPaths:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "strings(byAppendingPaths:)", "", "", "Argument[byAppendingPaths:].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "substring(from:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "substring(to:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "substring(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "trimmingCharacters(in:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "uppercased(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSString", true, "variantFittingPresentationWidth(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "append(_:count:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "Data", true, "insert(at:contentsOf:)", "", "", "Argument[contentsOf:]", "Argument[self]", "taint", "manual"] + - ["", "Data", true, "replaceSubrange(_:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "Data", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Data", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "Data", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[0].Parameter[0].CollectionElement", "Argument[self].CollectionElement", "taint", "manual"] + - ["", "Data", true, "withUnsafeMutableBytes(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "Data", true, "map(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "shuffled()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "shuffled(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "compactMap(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "flatMap(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "reduce(_:into:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "sorted()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "sorted(by:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "replace(_:maxReplacements:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "Data", true, "replacing(_:maxReplacements:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "Data", true, "replacing(_:maxReplacements:subrange:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "Data", true, "trimmingPrefix(while:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "trimmingPrefix(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "init(contentsOf:options:)", "", "", "Argument[contentsOf:]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "base64EncodedData(options:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "base64EncodedString(options:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "init(base64Encoded:options:)", "", "", "Argument[base64Encoded:]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "init(buffer:)", "", "", "Argument[buffer:]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "init(bytes:count:)", "", "", "Argument[bytes:]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "init(bytesNoCopy:count:deallocator:)", "", "", "Argument[bytesNoCopy:]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "init(referencing:)", "", "", "Argument[referencing:]", "ReturnValue", "taint", "manual"] + - ["", "Data", true, "replaceSubrange(_:count:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "Data", true, "sorted(using:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSObject", true, "copy()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSObject", true, "mutableCopy()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "Blob", true, "init(bytes:)", "", "", "Argument[bytes:]", "ReturnValue", "taint", "manual"] + - ["", "Blob", true, "init(bytes:length:)", "", "", "Argument[bytes:]", "ReturnValue", "taint", "manual"] + - ["", "Expression", true, "init(_:_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "Expression", true, "init(_:_:)", "", "", "Argument[1].CollectionElement", "ReturnValue", "taint", "manual"] + - ["", "NSCopying", true, "copy(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "ExpressionType", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "ExpressionType", true, "replace(_:with:)", "", "", "Argument[with:]", "ReturnValue", "taint", "manual"] + - ["", "InputStream", true, "init(data:)", "", "", "Argument[data:]", "ReturnValue", "taint", "manual"] + - ["", "NSMutableData", true, "append(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableData", true, "setData(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableData", true, "append(_:length:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableData", true, "replaceBytes(in:withBytes:)", "", "", "Argument[withBytes:]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableData", true, "replaceBytes(in:length:withBytes:)", "", "", "Argument[withBytes:]", "Argument[self]", "taint", "manual"] + - ["", "NSURL", true, "init(string:)", "(String)", "", "Argument[string:]", "ReturnValue.OptionalSome", "taint", "manual"] + - ["", "NSURL", true, "appendingPathExtension(for:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "NSURL", true, "appendingPathComponent(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSURL", true, "appendingPathExtension(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSURL", true, "appendingPathComponent(_:isDirectory:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSURL", true, "appendingPathComponent(_:conformingTo:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "NSMutableCopying", true, "mutableCopy(with:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "URLSession", true, "dataTask(completionHandler:with:)", "", "", "Argument[with:]", "Argument[completionHandler:].Parameter[0]", "taint", "manual"] + - ["", "WKUserScript", true, "init(forMainFrameOnly:injectionTime:source:)", "", "", "Argument[source:]", "ReturnValue", "taint", "manual"] + - ["", "WKUserScript", true, "init(forMainFrameOnly:in:injectionTime:source:)", "", "", "Argument[source:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "atIndex(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "defineProperty(_:descriptor:)", "", "", "Argument[descriptor:]", "Argument[self]", "taint", "manual"] + - ["", "JSValue", true, "forProperty(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(bool:in:)", "", "", "Argument[bool:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(double:in:)", "", "", "Argument[double:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(in:int32:)", "", "", "Argument[int32:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(in:object:)", "", "", "Argument[object:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(in:point:)", "", "", "Argument[point:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(in:range:)", "", "", "Argument[range:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(in:rect:)", "", "", "Argument[rect:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(in:size:)", "", "", "Argument[size:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "init(in:uInt32:)", "", "", "Argument[uInt32:]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "setValue(_:at:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "JSValue", true, "setValue(_:forProperty:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "JSValue", true, "toArray()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toBool()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toDate()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toDictionary()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toDouble()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toInt32()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toNumber()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toObject()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toObjectOf(_:)", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toPoint()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toRange()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toRect()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toSize()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toString()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "JSValue", true, "toUInt32()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "FilePath.Component", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "FilePath.Component", true, "init(platformString:)", "", "", "Argument[platformString:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath.Component", true, "withPlatformString(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0]", "taint", "manual"] + - ["", "FilePath.Root", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "FilePath.Root", true, "init(platformString:)", "", "", "Argument[platformString:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath.Root", true, "withPlatformString(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0]", "taint", "manual"] + - ["", "FilePath", true, "init(_:)", "", "", "Argument[0]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "append(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "FilePath", true, "init(extendedGraphemeClusterLiteral:)", "", "", "Argument[extendedGraphemeClusterLiteral:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "init(unicodeScalarLiteral:)", "", "", "Argument[unicodeScalarLiteral:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "encode(to:)", "", "", "Argument[self]", "Argument[to:]", "taint", "manual"] + - ["", "FilePath", true, "init(from:)", "", "", "Argument[from:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "init(stringLiteral:)", "(String)", "", "Argument[stringLiteral:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "withCString(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "FilePath", true, "withCString(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "init(cString:)", "", "", "Argument[cString:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "push(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "FilePath", true, "appending(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "init(platformString:)", "", "", "Argument[platformString:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "withPlatformString(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "FilePath", true, "withPlatformString(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "init(_:root:)", "", "", "Argument[root:,1]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "init(components:root:)", "", "", "Argument[root:,components:]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "lexicallyNormalized()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "lexicallyResolving(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "pushing(_:)", "", "", "Argument[self,0]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "removingLastComponent()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "FilePath", true, "removingRoot()", "", "", "Argument[self]", "ReturnValue", "taint", "manual"] + - ["", "DataProtocol", true, "copyBytes(to:)", "", "", "Argument[self]", "Argument[to:]", "taint", "manual"] + - ["", "DataProtocol", true, "copyBytes(count:to:)", "", "", "Argument[self]", "Argument[to:]", "taint", "manual"] + - ["", "DataProtocol", true, "copyBytes(from:to:)", "", "", "Argument[self]", "Argument[to:]", "taint", "manual"] + - ["", "ContiguousBytes", true, "withUnsafeBytes(_:)", "", "", "Argument[self]", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "ContiguousBytes", true, "withUnsafeBytes(_:)", "", "", "Argument[self].CollectionElement", "Argument[0].Parameter[0].CollectionElement", "taint", "manual"] + - ["", "ContiguousBytes", true, "withUnsafeBytes(_:)", "", "", "Argument[0].ReturnValue", "ReturnValue", "value", "manual"] + - ["", "URLResource", true, "init(bundle:locale:name:subdirectory:)", "", "", "Argument[name:,subdirectory:]", "ReturnValue", "taint", "manual"] + - ["", "NSMutableString", true, "append(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableString", true, "insert(_:at:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableString", true, "appendFormat(_:_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableString", true, "appendFormat(_:_:)", "", "", "Argument[1].CollectionElement", "Argument[self]", "taint", "manual"] + - ["", "NSMutableString", true, "replaceCharacters(in:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableString", true, "replaceOccurrences(of:options:range:with:)", "", "", "Argument[with:]", "Argument[self]", "taint", "manual"] + - ["", "NSMutableString", true, "setString(_:)", "", "", "Argument[0]", "Argument[self]", "taint", "manual"] diff --git a/unified/ql/lib/qlpack.yml b/unified/ql/lib/qlpack.yml index 84261b14adc7..beaa0eeb0666 100644 --- a/unified/ql/lib/qlpack.yml +++ b/unified/ql/lib/qlpack.yml @@ -12,5 +12,7 @@ dependencies: codeql/dataflow: ${workspace} codeql/namebinding: ${workspace} codeql/util: ${workspace} +dataExtensions: + - ext/*.model.yml warnOnImplicitThis: true compileForOverlayEval: true diff --git a/unified/ql/lib/unified.qll b/unified/ql/lib/unified.qll index b8dd4e9949fc..7aed5441f0f7 100644 --- a/unified/ql/lib/unified.qll +++ b/unified/ql/lib/unified.qll @@ -9,3 +9,4 @@ import codeql.unified.internal.AstExtra::Public import codeql.unified.internal.ControlFlowGraph::Public import codeql.unified.internal.NameBinding::Public import codeql.unified.internal.dataflow.DataFlowPublic +import codeql.unified.internal.mad.LegacyMaD::Public diff --git a/unified/ql/src/diagnostic/TaintSinks.ql b/unified/ql/src/diagnostic/TaintSinks.ql new file mode 100644 index 000000000000..5709909010a9 --- /dev/null +++ b/unified/ql/src/diagnostic/TaintSinks.ql @@ -0,0 +1,15 @@ +/** + * @name Taint sinks + * @description Taint sinks + * @kind problem + * @problem.severity recommendation + * @id unified/diagnostic/taint-sinks + * @tags meta + * @precision very-low + */ + +import unified + +from DataFlow::Node node, string kind +where Models::isSink(node, kind) +select node, "Sink of kind '" + kind + "'" diff --git a/unified/ql/src/diagnostic/TaintSources.ql b/unified/ql/src/diagnostic/TaintSources.ql new file mode 100644 index 000000000000..95695f45d284 --- /dev/null +++ b/unified/ql/src/diagnostic/TaintSources.ql @@ -0,0 +1,15 @@ +/** + * @name Taint sources + * @description Taint sources + * @kind problem + * @problem.severity recommendation + * @id unified/diagnostic/taint-sources + * @tags meta + * @precision very-low + */ + +import unified + +from DataFlow::Node node, string kind +where Models::isSource(node, kind) +select node, "Source of kind '" + kind + "'" diff --git a/unified/ql/src/summary/SummaryStats.ql b/unified/ql/src/summary/SummaryStats.ql new file mode 100644 index 000000000000..916d3388baff --- /dev/null +++ b/unified/ql/src/summary/SummaryStats.ql @@ -0,0 +1,14 @@ +/** + * @name Summary Statistics + * @description A table of summary statistics about a database. + * @kind metric + * @id unified/summary/summary-statistics + * @tags summary telemetry + */ + +import unified +import codeql.unified.internal.AnalysisQuality + +from string key, int value +where taintStats(key, value) +select key, value order by key diff --git a/unified/ql/test/library-tests/mad/test.expected b/unified/ql/test/library-tests/mad/test.expected new file mode 100644 index 000000000000..cac0df439216 --- /dev/null +++ b/unified/ql/test/library-tests/mad/test.expected @@ -0,0 +1,26 @@ +isSink +| test.swift:9:28:9:33 | string | path-injection | +| test.swift:11:25:11:30 | string | path-injection | +| test.swift:14:25:14:30 | string | path-injection | +| test.swift:18:17:18:22 | string | path-injection | +| test.swift:21:5:21:16 | [receiver arg] ... .md5(...) | weak-hash-input-MD5 | +| test.swift:23:20:23:25 | string | regex-use | +| test.swift:24:20:24:25 | string | regex-use | +| test.swift:71:37:71:49 | encodedOffset | string-length | +| test.swift:72:42:72:54 | encodedOffset | string-length | +| test.swift:76:24:76:36 | encryptionKey | encryption-key | +| test.swift:77:18:77:24 | fileURL | path-injection | +| test.swift:88:24:88:36 | encryptionKey | encryption-key | +| test.swift:89:18:89:24 | fileURL | path-injection | +| test.swift:100:24:100:36 | encryptionKey | encryption-key | +| test.swift:101:18:101:24 | fileURL | path-injection | +| test.swift:107:23:107:34 | seedFilePath | path-injection | +isSource +| test.swift:4:5:4:27 | String(...) | remote | +| test.swift:5:5:5:44 | String(...) | remote | +| test.swift:6:5:6:48 | String(...) | remote | +| test.swift:7:5:7:32 | ... .init(...) | remote | +| test.swift:9:5:9:34 | String(...) | local | +| test.swift:10:5:12:24 | String(...) | local | +| test.swift:13:5:15:28 | String(...) | local | +| test.swift:29:29:29:32 | text | local | diff --git a/unified/ql/test/library-tests/mad/test.ql b/unified/ql/test/library-tests/mad/test.ql new file mode 100644 index 000000000000..970aaa22e27f --- /dev/null +++ b/unified/ql/test/library-tests/mad/test.ql @@ -0,0 +1,5 @@ +private import unified + +query predicate isSource = Models::isSource/2; + +query predicate isSink = Models::isSink/2; diff --git a/unified/ql/test/library-tests/mad/test.qlref b/unified/ql/test/library-tests/mad/test.qlref new file mode 100644 index 000000000000..ab6773f15f90 --- /dev/null +++ b/unified/ql/test/library-tests/mad/test.qlref @@ -0,0 +1,2 @@ +query: test.ql +postprocess: utils/test/InlineExpectationsTestQuery.ql diff --git a/unified/ql/test/library-tests/mad/test.swift b/unified/ql/test/library-tests/mad/test.swift new file mode 100644 index 000000000000..bf895e5e9274 --- /dev/null +++ b/unified/ql/test/library-tests/mad/test.swift @@ -0,0 +1,110 @@ +func test(url: URL, string: String) { + String(url) // not a source + + String(contentsOf: url) // $ isSource=remote + String(contentsOf: url, encoding: .utf8) // $ isSource=remote + String(contentsOf: url, usedEncoding: .utf8) // $ isSource=remote + String.init(contentsOf: url) // $ isSource=remote + + String(contentsOfFile: string) // $ isSource=local isSink=path-injection + String( + contentsOfFile: string, // $ isSink=path-injection + encoding: .utf8) // $ isSource=local + String( + contentsOfFile: string, // $ isSink=path-injection + usedEncoding: .utf8) // $ isSource=local + + FileManager.default.createDirectory( + atPath: string, // $ isSink=path-injection + withIntermediateDirectories: true, attributes: nil) + + string.md5() // $ isSink=weak-hash-input-MD5 + + _ = try! Regex(string) // $ isSink=regex-use + _ = try! Regex(string, as: Substring.self) // $ isSink=regex-use + + class TestTextInput: UITextInput { + func shouldChangeText( + in range: UITextRange, + replacementText text: String // $ isSource=local // parameters not detected yet + ) -> Bool { + return true + } + } +} + +class UITextField { + var text: String = "" +} + +class URLSessionConfiguration { + var tlsMaximumSupportedProtocol: Int = 0 + var tlsMinimumSupportedProtocol: Int = 0 + var tlsMaximumSupportedProtocolVersion: Int = 0 + var tlsMinimumSupportedProtocolVersion: Int = 0 +} + +func testProperties( + string: String, + textField: UITextField, + configuration: URLSessionConfiguration +) { + _ = string.count // $ MISSING: isSource=string-length + _ = textField.text // $ MISSING: isSource=local + + configuration.tlsMaximumSupportedProtocol = 0 // $ MISSING: isSink=tls-protocol-version + configuration.tlsMinimumSupportedProtocol = 0 // $ MISSING: isSink=tls-protocol-version + configuration.tlsMaximumSupportedProtocolVersion = 0 // $ MISSING: isSink=tls-protocol-version + configuration.tlsMinimumSupportedProtocolVersion = 0 // $ MISSING: isSink=tls-protocol-version +} + +class Realm { + struct Configuration {} +} + +func testQualifiedConstructors( + encodedOffset: Int, + encryptionKey: String, + fileURL: String, + seedFilePath: String +) { + _ = String.Index(encodedOffset: encodedOffset) // $ isSink=string-length + _ = String.Index.init(encodedOffset: encodedOffset) // $ isSink=string-length + + _ = Realm.Configuration( + deleteRealmIfMigrationNeeded: false, + encryptionKey: encryptionKey, // $ isSink=encryption-key + fileURL: fileURL, // $ isSink=path-injection + inMemoryIdentifier: nil, + migrationBlock: nil, + objectTypes: nil, + readOnly: false, + schemaVersion: 0, + shouldCompactOnLaunch: nil, + syncConfiguration: nil) + + _ = Realm.Configuration.init( + deleteRealmIfMigrationNeeded: false, + encryptionKey: encryptionKey, // $ isSink=encryption-key + fileURL: fileURL, // $ isSink=path-injection + inMemoryIdentifier: nil, + migrationBlock: nil, + objectTypes: nil, + readOnly: false, + schemaVersion: 0, + shouldCompactOnLaunch: nil, + syncConfiguration: nil) + + _ = Realm.Configuration( + deleteRealmIfMigrationNeeded: false, + encryptionKey: encryptionKey, // $ isSink=encryption-key + fileURL: fileURL, // $ isSink=path-injection + inMemoryIdentifier: nil, + migrationBlock: nil, + objectTypes: nil, + readOnly: false, + schemaVersion: 0, + seedFilePath: seedFilePath, // $ isSink=path-injection + shouldCompactOnLaunch: nil, + syncConfiguration: nil) +}