Function Implementation Swift (Swizzle)

let function = Function(name: funcName, args: args) { [unowned self] (i, a) in
            guard argCount == a.count && !(args == Interpreter._variableLengthParameters) else {
                if self.stackTrace {
                    self.logMsg("Incorrect number of arguments. Expected \(argCount), given: \(a.count).", ui: "Input arguments: \(a), required arguments: \(args).")
                    self.logMsg("Arguments are not variable length.", ui: "Only varible length functions can have variable amounts of input arguments.")
                }
                self.reportError("Expected \(argCount) argument\(argCount == 1 ? "" : "s") in function call to '\(funcName)(_:)'")
                return
            }
            for statement in body {
                if let call = statement as? CallStatement {
                    var i = 0
                    var ua = 0
                    var newArgs = [Expression]()
                    call.args.forEach { (expr) in
                        if let n = expr.rep.anyToken?.lexme {
                            if ua < a.endIndex,  n == args[ua] {
                                let result = Token(type: TokenType.literal, lexme: a[ua], literal: nil, line: nil)
                                let newExpr = Expression(rep: .anyToken(result))
                                self.visit(newExpr)
                                newArgs.append(newExpr)
                                ua += 1
                            } else {
                                newArgs.append(expr)
                            }

                        } else if let access = expr.rep.access {
                            access
                            guard let index = args.index(where: { $0 == access.object.lexme }) else {
                                self.reportError("Unresolved identifier '\(access.key.lexme)'")
                                return

                            }

                            let objcName = self.nowhite(a[index])

                            guard let val = self.objects[objcName]?.values[access.key.lexme] else {
                                self.reportError("Unknown property '\(access.key.lexme)'")
                                return
                            }
                            let result = Token(type: .literal, lexme: val, literal: val, line: nil)
                            let newExpr = Expression(rep: .anyToken(result))
                            self.visit(newExpr)
                            newArgs.append(newExpr)
                            ua += 1
                        }
                        i += 1
                    }
                    let newCall = CallStatement(name: call.name, args: newArgs)
                    self.visit(newCall)
                } else if let cond = statement as? IfStatement {

                }
            }
        }