Skip to content

Commit d0df556

Browse files
pjtnt11pjtnt11
committed
Update Swift Syntax to 602.0.0
1 parent dcab218 commit d0df556

File tree

3 files changed

+231
-24
lines changed

3 files changed

+231
-24
lines changed

‎Package.swift‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,15 +25,15 @@ let package = Package(
2525
dependencies: [
2626
.package(
2727
url: "https://github.com/fetch-rewards/swift-locking.git",
28-
exact: "0.2.0"
28+
exact: "0.2.1"
2929
),
3030
.package(
3131
url: "https://github.com/swiftlang/swift-syntax.git",
32-
exact: "600.0.0" // Must match SwiftSyntaxSugar's swift-syntax version
32+
from: "602.0.0" // Must match SwiftSyntaxSugar's swift-syntax version
3333
),
3434
.package(
3535
url: "https://github.com/fetch-rewards/SwiftSyntaxSugar.git",
36-
exact: "0.1.1" // Must match swift-locking's SwiftSyntaxSugar version
36+
from: "0.1.2" // Must match swift-locking's SwiftSyntaxSugar version
3737
),
3838
],
3939
targets: [

‎Sources/MockingMacros/Macros/MockedMethodMacro/MockedMethodMacro+TypeErasure.swift‎

Lines changed: 80 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -247,6 +247,15 @@ extension MockedMethodMacro {
247247
ifTypeIsContainedIn: genericParameters,
248248
typeConstrainedBy: genericWhereClause
249249
)
250+
case var .inlineArrayType(type):
251+
let (element, didTypeEraseElement) = self.syntax(
252+
type.element,
253+
ifTypeIsContainedIn: genericParameters,
254+
typeConstrainedBy: genericWhereClause
255+
)
256+
257+
type = type.with(\.element, element)
258+
result = (newType: type, didTypeErase: didTypeEraseElement)
250259
case let .tupleType(type):
251260
result = self.syntax(
252261
type,
@@ -456,9 +465,7 @@ extension MockedMethodMacro {
456465
):
457466
let (newGenericArgumentClause, didTypeErase) = self.syntax(
458467
genericArgumentClause,
459-
withElementsInCollectionAt: \.arguments,
460-
typeErasedAt: \.argument,
461-
ifTypeIsContainedIn: genericParameters,
468+
typeErasedIfElementsIn: genericParameters,
462469
typeConstrainedBy: genericWhereClause
463470
)
464471
let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
@@ -470,9 +477,7 @@ extension MockedMethodMacro {
470477
):
471478
let (newGenericArgumentClause, didTypeErase) = self.syntax(
472479
genericArgumentClause,
473-
withElementsInCollectionAt: \.arguments,
474-
typeErasedAt: \.argument,
475-
ifTypeIsContainedIn: genericParameters,
480+
typeErasedIfElementsIn: genericParameters,
476481
typeConstrainedBy: genericWhereClause
477482
) { index in
478483
index == .zero ? AnyHashable.self : Any.self
@@ -487,9 +492,7 @@ extension MockedMethodMacro {
487492
):
488493
let (newGenericArgumentClause, didTypeErase) = self.syntax(
489494
genericArgumentClause,
490-
withElementsInCollectionAt: \.arguments,
491-
typeErasedAt: \.argument,
492-
ifTypeIsContainedIn: genericParameters,
495+
typeErasedIfElementsIn: genericParameters,
493496
typeConstrainedBy: genericWhereClause
494497
)
495498
let newType = type.with(\.genericArgumentClause, newGenericArgumentClause)
@@ -502,9 +505,7 @@ extension MockedMethodMacro {
502505
):
503506
let (newGenericArgumentClause, didTypeErase) = self.syntax(
504507
genericArgumentClause,
505-
withElementsInCollectionAt: \.arguments,
506-
typeErasedAt: \.argument,
507-
ifTypeIsContainedIn: genericParameters,
508+
typeErasedIfElementsIn: genericParameters,
508509
typeConstrainedBy: genericWhereClause
509510
) { index in
510511
index == .zero ? AnyHashable.self : Any.self
@@ -515,9 +516,7 @@ extension MockedMethodMacro {
515516
default:
516517
let (_, didTypeErase) = self.syntax(
517518
genericArgumentClause,
518-
withElementsInCollectionAt: \.arguments,
519-
typeErasedAt: \.argument,
520-
ifTypeIsContainedIn: genericParameters,
519+
typeErasedIfElementsIn: genericParameters,
521520
typeConstrainedBy: genericWhereClause
522521
)
523522

@@ -531,6 +530,72 @@ extension MockedMethodMacro {
531530
}
532531
}
533532

533+
private static func syntax(
534+
_ argument: GenericArgumentSyntax,
535+
ifTypeIsContainedIn genericParameters: GenericParameterListSyntax?,
536+
typeConstrainedBy genericWhereClause: GenericWhereClauseSyntax?,
537+
typeErasedType: (some Any).Type = Any.self
538+
) -> (GenericArgumentSyntax, Bool) {
539+
guard case let .type(type) = argument.argument else {
540+
return (argument, false)
541+
}
542+
543+
let (erasedType, didTypeErase) = self.type(
544+
type,
545+
typeErasedIfNecessaryUsing: genericParameters,
546+
typeConstrainedBy: genericWhereClause,
547+
typeErasedType: typeErasedType
548+
)
549+
550+
let newArgument = argument.with(
551+
\.argument,
552+
.type(TypeSyntax(erasedType))
553+
)
554+
555+
return (newArgument, didTypeErase)
556+
}
557+
558+
private static func syntax(
559+
_ clause: GenericArgumentClauseSyntax,
560+
typeErasedIfElementsIn genericParameters: GenericParameterListSyntax?,
561+
typeConstrainedBy genericWhereClause: GenericWhereClauseSyntax?,
562+
typeErasedType: (Int) -> Any.Type
563+
) -> (GenericArgumentClauseSyntax, Bool) {
564+
var didTypeErase = false
565+
var newArguments: [GenericArgumentSyntax] = []
566+
567+
for (index, argument) in clause.arguments.enumerated() {
568+
let (newArgument, didTypeEraseArgument) = self.syntax(
569+
argument,
570+
ifTypeIsContainedIn: genericParameters,
571+
typeConstrainedBy: genericWhereClause,
572+
typeErasedType: typeErasedType(index)
573+
)
574+
575+
newArguments.append(newArgument)
576+
didTypeErase = didTypeErase || didTypeEraseArgument
577+
}
578+
579+
let newClause = clause.with(
580+
\.arguments,
581+
GenericArgumentListSyntax(newArguments)
582+
)
583+
584+
return (newClause, didTypeErase)
585+
}
586+
587+
private static func syntax(
588+
_ clause: GenericArgumentClauseSyntax,
589+
typeErasedIfElementsIn genericParameters: GenericParameterListSyntax?,
590+
typeConstrainedBy genericWhereClause: GenericWhereClauseSyntax?
591+
) -> (GenericArgumentClauseSyntax, Bool) {
592+
self.syntax(
593+
clause,
594+
typeErasedIfElementsIn: genericParameters,
595+
typeConstrainedBy: genericWhereClause
596+
) { _ in Any.self }
597+
}
598+
534599
/// Returns a Boolean value indicating whether the provided identifier
535600
/// type's name matches any of the provided `names`.
536601
///

‎Sources/MockingMacros/Models/MockMethodNameComponents/MockMethodNameComponents.swift‎

Lines changed: 148 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -228,6 +228,8 @@ extension MockMethodNameComponents {
228228
self.capitalizedDescription(of: type)
229229
case let .attributedType(type):
230230
self.capitalizedDescription(of: type)
231+
case let .inlineArrayType(type):
232+
self.capitalizedDescription(of: type)
231233
case let .classRestrictionType(type):
232234
self.capitalizedDescription(of: type.classKeyword)
233235
case let .compositionType(type):
@@ -296,6 +298,8 @@ extension MockMethodNameComponents {
296298
result += specifier.arguments.reduce("") { result, argument in
297299
result + self.capitalizedDescription(of: argument.parameter)
298300
}
301+
case let .nonisolatedTypeSpecifier(specifier):
302+
result += self.capitalizedDescription(of: specifier)
299303
}
300304
}
301305
let baseTypeDescription = self.capitalizedDescription(of: type.baseType)
@@ -440,9 +444,19 @@ extension MockMethodNameComponents {
440444
return nameDescription + "Of" + genericArgumentsDescription
441445
}
442446

443-
return self.capitalizedDescription(
444-
of: DictionaryTypeSyntax(key: key, value: value)
445-
)
447+
if
448+
let keyType = Self.type(from: key),
449+
let valueType = Self.type(from: value)
450+
{
451+
return self.capitalizedDescription(
452+
of: DictionaryTypeSyntax(key: keyType, value: valueType)
453+
)
454+
}
455+
456+
let keyDescription = Self.capitalizedDescription(of: key)
457+
let valueDescription = Self.capitalizedDescription(of: value)
458+
459+
return "DictionaryOf" + keyDescription + "To" + valueDescription
446460
}
447461

448462
/// Returns a capitalized description of the provided `type`.
@@ -503,9 +517,20 @@ extension MockMethodNameComponents {
503517
return baseTypeDescription + nameDescription + "Of" + genericArgumentsDescription
504518
}
505519

506-
let dictionaryDescription = self.capitalizedDescription(
507-
of: DictionaryTypeSyntax(key: key, value: value)
508-
)
520+
let dictionaryDescription: String
521+
522+
if
523+
let keyType = Self.type(from: key),
524+
let valueType = Self.type(from: value)
525+
{
526+
dictionaryDescription = self.capitalizedDescription(
527+
of: DictionaryTypeSyntax(key: keyType, value: valueType)
528+
)
529+
} else {
530+
let keyDescription = Self.capitalizedDescription(of: key)
531+
let valueDescription = Self.capitalizedDescription(of: value)
532+
dictionaryDescription = "DictionaryOf" + keyDescription + "To" + valueDescription
533+
}
509534

510535
return baseTypeDescription + dictionaryDescription
511536
}
@@ -693,4 +718,121 @@ extension MockMethodNameComponents {
693718

694719
return description
695720
}
721+
722+
/// Returns a capitalized description of the provided `type`.
723+
///
724+
/// - Parameter type: The inline array type syntax to describe.
725+
///
726+
/// - Returns: A capitalized description of the provided `type`.
727+
private static func capitalizedDescription(
728+
of type: InlineArrayTypeSyntax
729+
) -> String {
730+
let countDescription = self.capitalizedDescription(of: type.count.argument)
731+
let elementDescription = self.capitalizedDescription(of: type.element.argument)
732+
733+
return "InlineArrayOf" + countDescription + "Of" + elementDescription
734+
}
735+
736+
/// Returns a capitalized description of the provided `argument`.
737+
///
738+
/// - Parameter argument: The generic argument syntax to describe.
739+
///
740+
/// - Returns: A capitalized description of the provided `argument`.
741+
private static func capitalizedDescription(
742+
of argument: GenericArgumentSyntax.Argument
743+
) -> String {
744+
switch argument {
745+
case let .type(type):
746+
self.capitalizedDescription(of: type)
747+
case let .expr(expr):
748+
self.capitalizedDescription(of: expr)
749+
}
750+
}
751+
752+
/// Returns a capitalized description of the provided `expression`.
753+
///
754+
/// - Parameter expression: The expression syntax to describe.
755+
///
756+
/// - Returns: A capitalized description of the provided `expression`.
757+
private static func capitalizedDescription(
758+
of expression: ExprSyntax
759+
) -> String {
760+
expression.trimmedDescription.withFirstCharacterCapitalized()
761+
}
762+
763+
/// Returns a capitalized description of the provided `specifier`.
764+
///
765+
/// - Parameter specifier: The nonisolated type specifier syntax to describe.
766+
///
767+
/// - Returns: A capitalized description of the provided `specifier`.
768+
private static func capitalizedDescription(
769+
of specifier: NonisolatedTypeSpecifierSyntax
770+
) -> String {
771+
var description = self.capitalizedDescription(of: specifier.nonisolatedKeyword)
772+
773+
if let argument = specifier.argument {
774+
description += Self.capitalizedDescription(of: argument)
775+
}
776+
777+
return description
778+
}
779+
780+
/// Returns a capitalized description of the provided `argument`.
781+
///
782+
/// - Parameter argument: The nonisolated specifier argument syntax to describe.
783+
///
784+
/// - Returns: A capitalized description of the provided `argument`.
785+
private static func capitalizedDescription(
786+
of argument: NonisolatedSpecifierArgumentSyntax
787+
) -> String {
788+
argument.trimmedDescription.withFirstCharacterCapitalized()
789+
}
790+
791+
/// Returns a capitalized description of the provided `type`.
792+
///
793+
/// - Parameter type: The same-type requirement's left type to describe.
794+
///
795+
/// - Returns: A capitalized description of the provided `type`.
796+
private static func capitalizedDescription(
797+
of type: SameTypeRequirementSyntax.LeftType
798+
) -> String {
799+
switch type {
800+
case let .type(type):
801+
self.capitalizedDescription(of: type)
802+
case let .expr(expr):
803+
self.capitalizedDescription(of: expr)
804+
}
805+
}
806+
807+
/// Returns a capitalized description of the provided `type`.
808+
///
809+
/// - Parameter type: The same-type requirement's right type to describe.
810+
///
811+
/// - Returns: A capitalized description of the provided `type`.
812+
private static func capitalizedDescription(
813+
of type: SameTypeRequirementSyntax.RightType
814+
) -> String {
815+
switch type {
816+
case let .type(type):
817+
self.capitalizedDescription(of: type)
818+
case let .expr(expr):
819+
self.capitalizedDescription(of: expr)
820+
}
821+
}
822+
823+
/// Returns a `TypeSyntax` when the provided `argument` is a type argument.
824+
///
825+
/// - Parameter argument: The generic argument from which to extract a type.
826+
///
827+
/// - Returns: A `TypeSyntax` if the argument represents a type; otherwise, `nil`.
828+
private static func type(
829+
from argument: GenericArgumentSyntax.Argument
830+
) -> TypeSyntax? {
831+
switch argument {
832+
case let .type(type):
833+
type
834+
case .expr:
835+
nil
836+
}
837+
}
696838
}

0 commit comments

Comments
 (0)