How to use shortName method of MethodTemplate class

...64                    isBridged: false,65                    isThrowing: method.isThrowing,66                    isStatic: method.kind.typeScope.isStatic,67                    callMember: { scope in68                      let scopedName = "\(scope).\(backticked: self.method.shortName)"69                      guard self.method.isVariadic else {70                        return FunctionCallTemplate(71                          name: scopedName,72                          arguments: self.invocationArguments,73                          isThrowing: self.method.isThrowing).render()74                      }75                      76                      // Variadic functions require casting since Swift doesn't support splatting.77                      let name = FunctionCallTemplate(78                        name: "Swift.unsafeBitCast",79                        arguments: [80                          (nil, "\(scopedName) as \(self.originalSignature)"),81                          ("to", "\(parenthetical: self.longSignature).self")])82                      return FunctionCallTemplate(83                        name: name.render(),84                        unlabeledArguments: self.invocationArguments.map({ $0.parameterName }),85                        isThrowing: self.method.isThrowing).render()86                    },87                    invocationArguments: invocationArguments).render()88    let declaration = "public \(overridableModifiers)func \(fullNameForMocking)\(returnTypeAttributesForMocking) -> \(mockableReturnType)"89    return String(lines: [90      "// MARK: Mocked \(fullNameForMocking)",91      FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,92                                 declaration: declaration,93                                 genericConstraints: method.whereClauses.map({ context.specializeTypeName("\($0)") }),94                                 body: body).render(),95    ])96  }97  98  /// Declared in a class, or a class that the protocol conforms to.99  lazy var isClassBound: Bool = {100    let isClassDefinedProtocolConformance = context.protocolClassConformance != nil101      && method.isOverridable102    return context.mockableType.kind == .class || isClassDefinedProtocolConformance103  }()104  105  var overridableUniqueDeclaration: String {106    return "\(fullNameForMocking)\(returnTypeAttributesForMocking) -> \(mockableReturnType)\(genericConstraints)"107  }108  109  lazy var uniqueDeclaration: String = { return overridableUniqueDeclaration }()110  111  /// Methods synthesized specifically for the stubbing and verification APIs.112  var synthesizedDeclarations: String {113    let invocationType = "(\(separated: matchableParameterTypes)) \(returnTypeAttributesForMatching)-> \(matchableReturnType)"114    115    var methods = [String]()116    let genericTypes = [declarationTypeForMocking, invocationType, matchableReturnType]117    let returnType = "Mockingbird.Mockable<\(separated: genericTypes)>"118    119    let declaration = "public \(regularModifiers)func \(fullNameForMatching) -> \(returnType)"120    let genericConstraints = method.whereClauses.map({ context.specializeTypeName("\($0)") })121    122    let body = !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """123    return \(ObjectInitializationTemplate(124              name: "Mockingbird.Mockable",125              genericTypes: genericTypes,126              arguments: [("mock", mockObject), ("invocation", matchableInvocation())]))127    """128    methods.append(129      FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,130                                 declaration: declaration,131                                 genericConstraints: genericConstraints,132                                 body: body).render())133    134    // Variadics generate both the array and variadic-forms of the function signature to allow use135    // of either when stubbing and verifying.136    if method.isVariadic {137      let body = !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """138      return \(ObjectInitializationTemplate(139                name: "Mockingbird.Mockable",140                genericTypes: genericTypes,141                arguments: [("mock", mockObject),142                            ("invocation", matchableInvocation(isVariadic: true))]))143      """144      let declaration = "public \(regularModifiers)func \(fullNameForMatchingVariadics) -> \(returnType)"145      methods.append(146        FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,147                                   declaration: declaration,148                                   genericConstraints: genericConstraints,149                                   body: body).render())150    }151    152    return String(lines: methods, spacing: 2)153  }154  155  /// Modifiers specifically for stubbing and verification methods.156  lazy var regularModifiers: String = { return modifiers(allowOverride: false) }()157  /// Modifiers for mocked methods.158  lazy var overridableModifiers: String = { return modifiers(allowOverride: true) }()159  func modifiers(allowOverride: Bool = true) -> String {160    let isRequired = method.attributes.contains(.required)161    let required = (isRequired || method.isInitializer ? "required " : "")162    let shouldOverride = method.isOverridable && !isRequired && allowOverride163    let override = shouldOverride ? "override " : ""164    let `static` = method.kind.typeScope.isStatic ? "static " : ""165    return "\(required)\(override)\(`static`)"166  }167  168  lazy var genericTypes: [String] = {169    return method.genericTypes.map({ $0.flattenedDeclaration })170  }()171  172  lazy var genericConstraints: String = {173    guard !method.whereClauses.isEmpty else { return "" }174    return " where \(separated: method.whereClauses.map({ context.specializeTypeName("\($0)") }))"175  }()176  177  enum FunctionVariant {178    case function, subscriptGetter, subscriptSetter179    180    var isSubscript: Bool {181      switch self {182      case .function: return false183      case .subscriptGetter, .subscriptSetter: return true184      }185    }186  }187  188  enum FullNameMode {189    case mocking(variant: FunctionVariant)190    case matching(useVariadics: Bool, variant: FunctionVariant)191    case initializerProxy192    193    var isMatching: Bool {194      switch self {195      case .matching: return true196      case .mocking, .initializerProxy: return false197      }198    }199    200    var isInitializerProxy: Bool {201      switch self {202      case .matching, .mocking: return false203      case .initializerProxy: return true204      }205    }206    207    var useVariadics: Bool {208      switch self {209      case .matching(let useVariadics, _): return useVariadics210      case .mocking, .initializerProxy: return false211      }212    }213    214    var variant: FunctionVariant {215      switch self {216      case .matching(_, let variant), .mocking(let variant): return variant217      case .initializerProxy: return .function218      }219    }220  }221  222  func shortName(for mode: FullNameMode) -> String {223    let failable: String224    if mode.isInitializerProxy {225      failable = ""226    } else if method.attributes.contains(.failable) {227      failable = "?"228    } else if method.attributes.contains(.unwrappedFailable) {229      failable = "!"230    } else {231      failable = ""232    }233    234    // Don't escape initializers, subscripts, and special functions with reserved tokens like `==`.235    let shouldEscape = !method.isInitializer236      && method.kind != .functionSubscript237      && (method.shortName.first?.isLetter == true238        || method.shortName.first?.isNumber == true239        || method.shortName.first == "_")240    let escapedShortName = mode.isInitializerProxy ? "initialize" :241      (shouldEscape ? method.shortName.backtickWrapped : method.shortName)242    243    return genericTypes.isEmpty244      ? "\(escapedShortName)\(failable)"245      : "\(escapedShortName)\(failable)<\(separated: genericTypes)>"246  }247  248  lazy var fullNameForMocking: String = {249    return fullName(for: .mocking(variant: .function))250  }()251  lazy var fullNameForMatching: String = {252    return fullName(for: .matching(useVariadics: false, variant: .function))253  }()254  /// It's not possible to have an autoclosure with variadics. However, since a method can only have255  /// one variadic parameter, we can generate one method for wildcard matching using an argument256  /// matcher, and another for specific matching using variadics.257  lazy var fullNameForMatchingVariadics: String = {258    return fullName(for: .matching(useVariadics: true, variant: .function))259  }()260  func fullName(for mode: FullNameMode) -> String {261    let additionalParameters: [String]262    if mode.isInitializerProxy {263      additionalParameters = ["__file: StaticString = #file", "__line: UInt = #line"]264    } else if mode.variant == .subscriptSetter {265      let closureType = mode.isMatching ? "@autoclosure () -> " : ""266      additionalParameters = ["`newValue`: \(closureType)\(matchableReturnType)"]267    } else {268      additionalParameters = []269    }270    271    let parameterNames = method.parameters.map({ parameter -> String in272      let typeName: String273      if mode.isMatching && (!mode.useVariadics || !parameter.attributes.contains(.variadic)) {274        typeName = "@autoclosure () -> \(parameter.matchableTypeName(in: self))"275      } else {276        typeName = parameter.mockableTypeName(context: self)277      }278      let argumentLabel = parameter.argumentLabel ?? "_"279      let parameterName = parameter.name.backtickWrapped280      if argumentLabel.backtickUnwrapped != parameter.name {281        return "\(argumentLabel) \(parameterName): \(typeName)"282      } else if mode.isMatching && mode.variant.isSubscript {283        // Synthesized declarations for subscripts don't use argument labels (unless the parameter284        // name differs) for parity with bracket syntax.285        return "_ \(parameterName): \(typeName)"286      } else {287        return "\(parameterName): \(typeName)"288      }289    }) + additionalParameters290    291    let actualShortName = shortName(for: mode)292    let shortName: String293    if mode.isMatching, let resolvedShortName = Constants.reservedNamesMap[actualShortName] {294      shortName = resolvedShortName295    } else {296      shortName = actualShortName297    }298    299    return "\(shortName)(\(separated: parameterNames))"300  }301  302  lazy var mockableInvocation: String = {303    return ObjectInitializationTemplate(304      name: "Mockingbird.SwiftInvocation",305      arguments: [306        ("selectorName", "\(doubleQuoted: uniqueDeclaration)"),307        ("selectorType", "Mockingbird.SelectorType.method"),308        ("arguments", "[\(separated: mockArgumentMatchers)]"),309        ("returnType", "Swift.ObjectIdentifier(\(parenthetical: matchableReturnType).self)"),310      ]).render()311  }()312  313  func matchableInvocation(isVariadic: Bool = false) -> String {...

1let method = MethodTemplate()2let shortName = method.shortName("Hello World")3print(shortName)4let method = MethodTemplate()5let longName = method.longName("Hello World")6print(longName)7let method = MethodTemplate()8let shortName = method.shortName("Hello World")9print(shortName)10let method = MethodTemplate()11let longName = method.longName("Hello World")12print(longName)13let method = MethodTemplate()14let shortName = method.shortName("Hello World")15print(shortName)16let method = MethodTemplate()17let longName = method.longName("Hello World")18print(longName)19let method = MethodTemplate()20let shortName = method.shortName("Hello World")21print(shortName)22let method = MethodTemplate()23let longName = method.longName("Hello World")24print(longName)25let method = MethodTemplate()26let shortName = method.shortName("Hello World")27print(shortName)28let method = MethodTemplate()29let longName = method.longName("Hello World")30print(longName)31let method = MethodTemplate()32let shortName = method.shortName("Hello World")33print(shortName)34let method = MethodTemplate()35let longName = method.longName("Hello World")36print(longName)37let method = MethodTemplate()38let shortName = method.shortName("Hello World")

1let template = MethodTemplate()2template.shortName("Swift is awesome")3let template = MethodTemplate()4template.shortName("Swift is awesome")5let template = MethodTemplate()6template.shortName("Swift is awesome")7let template = MethodTemplate()8template.shortName("Swift is awesome")9let template = MethodTemplate()10template.shortName("Swift is awesome")11let template = MethodTemplate()12template.shortName("Swift is awesome")13let template = MethodTemplate()14template.shortName("Swift is awesome")15let template = MethodTemplate()16template.shortName("Swift is awesome")17let template = MethodTemplate()18template.shortName("Swift is awesome")19let template = MethodTemplate()20template.shortName("Swift is awesome")21let template = MethodTemplate()22template.shortName("Swift is awesome")23let template = MethodTemplate()24template.shortName("Swift is awesome")25let template = MethodTemplate()26template.shortName("Swift is awesome")27let template = MethodTemplate()28template.shortName("Swift is awesome")29let template = MethodTemplate()30template.shortName("Swift is awesome")

1let method = MethodTemplate("myMethod")2let shortName = method.shortName()3print(shortName)4let method = MethodTemplate("myMethod")5let shortName = method.shortName()6print(shortName)7let method = MethodTemplate("myMethod")8let shortName = method.shortName()9print(shortName)10let method = MethodTemplate("myMethod")11let shortName = method.shortName()12print(shortName)13let method = MethodTemplate("myMethod")14let shortName = method.shortName()15print(shortName)16let method = MethodTemplate("myMethod")17let shortName = method.shortName()18print(shortName)19let method = MethodTemplate("myMethod")20let shortName = method.shortName()21print(shortName)22let method = MethodTemplate("myMethod")23let shortName = method.shortName()24print(shortName)25let method = MethodTemplate("myMethod")26let shortName = method.shortName()27print(shortName)28let method = MethodTemplate("myMethod")29let shortName = method.shortName()30print(shortName)31let method = MethodTemplate("myMethod")32let shortName = method.shortName()33print(shortName)34let method = MethodTemplate("myMethod")35let shortName = method.shortName()36print(shortName)37let method = MethodTemplate("myMethod")38let shortName = method.shortName()

1import Foundation2let method = MethodTemplate(name: "foo", shortName: "bar")3print(method.shortName)4import Foundation5let method = MethodTemplate(name: "foo", shortName: "bar")6print(method.shortName)7import Foundation8let method = MethodTemplate(name: "foo", shortName: "bar")9print(method.shortName)10import Foundation11let method = MethodTemplate(name: "foo", shortName: "bar")12print(method.shortName)13import Foundation14let method = MethodTemplate(name: "foo", shortName: "bar")15print(method.shortName)16import Foundation17let method = MethodTemplate(name: "foo", shortName: "bar")18print(method.shortName)19import Foundation20let method = MethodTemplate(name: "foo", shortName: "bar")21print(method.shortName)22import Foundation23let method = MethodTemplate(name: "foo", shortName: "bar")24print(method.shortName)25import Foundation26let method = MethodTemplate(name: "foo", shortName: "bar")27print(method.shortName)28import Foundation29let method = MethodTemplate(name: "foo", shortName: "bar")30print(method.shortName)31import Foundation32let method = MethodTemplate(name: "foo", shortName: "bar")33print(method.shortName)34import Foundation35let method = MethodTemplate(name: "foo", shortName: "bar")36print(method.shortName)

1import Foundation2var obj = MethodTemplate()3obj.shortName("Karthik")4import Foundation5var obj = MethodTemplate()6obj.shortName("Karthik", "Murali")7import Foundation8var obj = MethodTemplate()9obj.shortName("Karthik", "Murali", "Kumar")10import Foundation11var obj = MethodTemplate()12obj.shortName("Karthik", "Murali", "Kumar", "S")13import Foundation14var obj = MethodTemplate()15obj.shortName("Karthik", "Murali", "Kumar", "S", "B")16import Foundation17var obj = MethodTemplate()18obj.shortName("Karthik", "Murali", "Kumar", "S", "B", "M")19import Foundation20var obj = MethodTemplate()21obj.shortName("Karthik", "Murali", "Kumar", "S", "B", "M", "S")