mirror of
https://github.com/realm/SwiftLint.git
synced 2026-06-06 20:18:40 +00:00
This reverts commit 56461c3ab4.
This commit is contained in:
Danny Mösch
GitHub
@@ -9,16 +9,16 @@ struct DiscouragedObjectLiteralRule: SwiftSyntaxRule, OptInRule, ConfigurationPr
|
||||
description: "Prefer initializers over object literals",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"let image = UIImage(named: aVariable)",
|
||||
"let image = UIImage(named: \"interpolated \\(variable)\")",
|
||||
"let color = UIColor(red: value, green: value, blue: value, alpha: 1)",
|
||||
"let image = NSImage(named: aVariable)",
|
||||
"let image = NSImage(named: \"interpolated \\(variable)\")",
|
||||
"let color = NSColor(red: value, green: value, blue: value, alpha: 1)"
|
||||
Example("let image = UIImage(named: aVariable)"),
|
||||
Example("let image = UIImage(named: \"interpolated \\(variable)\")"),
|
||||
Example("let color = UIColor(red: value, green: value, blue: value, alpha: 1)"),
|
||||
Example("let image = NSImage(named: aVariable)"),
|
||||
Example("let image = NSImage(named: \"interpolated \\(variable)\")"),
|
||||
Example("let color = NSColor(red: value, green: value, blue: value, alpha: 1)")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"let image = ↓#imageLiteral(resourceName: \"image.jpg\")",
|
||||
"let color = ↓#colorLiteral(red: 0.9607843161, green: 0.7058823705, blue: 0.200000003, alpha: 1)"
|
||||
Example("let image = ↓#imageLiteral(resourceName: \"image.jpg\")"),
|
||||
Example("let color = ↓#colorLiteral(red: 0.9607843161, green: 0.7058823705, blue: 0.200000003, alpha: 1)")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,22 +9,22 @@ struct ExplicitTopLevelACLRule: SwiftSyntaxRule, OptInRule, ConfigurationProvide
|
||||
description: "Top-level declarations should specify Access Control Level keywords explicitly",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"internal enum A {}\n",
|
||||
"public final class B {}\n",
|
||||
"private struct C {}\n",
|
||||
"internal enum A {\n enum B {}\n}",
|
||||
"internal final class Foo {}",
|
||||
"internal\nclass Foo {}",
|
||||
"internal func a() {}\n",
|
||||
"extension A: Equatable {}",
|
||||
"extension A {}"
|
||||
Example("internal enum A {}\n"),
|
||||
Example("public final class B {}\n"),
|
||||
Example("private struct C {}\n"),
|
||||
Example("internal enum A {\n enum B {}\n}"),
|
||||
Example("internal final class Foo {}"),
|
||||
Example("internal\nclass Foo {}"),
|
||||
Example("internal func a() {}\n"),
|
||||
Example("extension A: Equatable {}"),
|
||||
Example("extension A {}")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓enum A {}\n",
|
||||
"final ↓class B {}\n",
|
||||
"↓struct C {}\n",
|
||||
"↓func a() {}\n",
|
||||
"internal let a = 0\n↓func b() {}\n"
|
||||
Example("↓enum A {}\n"),
|
||||
Example("final ↓class B {}\n"),
|
||||
Example("↓struct C {}\n"),
|
||||
Example("↓func a() {}\n"),
|
||||
Example("internal let a = 0\n↓func b() {}\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,9 +9,9 @@ struct ForceCastRule: ConfigurationProviderRule, SwiftSyntaxRule {
|
||||
description: "Force casts should be avoided",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"NSNumber() as? Int\n"
|
||||
Example("NSNumber() as? Int\n")
|
||||
],
|
||||
triggeringExamples: [ "NSNumber() ↓as! Int\n" ]
|
||||
triggeringExamples: [ Example("NSNumber() ↓as! Int\n") ]
|
||||
)
|
||||
|
||||
func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
|
||||
|
||||
@@ -14,36 +14,36 @@ struct GenericTypeNameRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
"uppercase character and span between 1 and 20 characters in length.",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"func foo<T>() {}\n",
|
||||
"func foo<T>() -> T {}\n",
|
||||
"func foo<T, U>(param: U) -> T {}\n",
|
||||
"func foo<T: Hashable, U: Rule>(param: U) -> T {}\n",
|
||||
"struct Foo<T> {}\n",
|
||||
"class Foo<T> {}\n",
|
||||
"enum Foo<T> {}\n",
|
||||
"func run(_ options: NoOptions<CommandantError<()>>) {}\n",
|
||||
"func foo(_ options: Set<type>) {}\n",
|
||||
"func < <T: Comparable>(lhs: T?, rhs: T?) -> Bool\n",
|
||||
"func configureWith(data: Either<MessageThread, (project: Project, backing: Backing)>)\n",
|
||||
"typealias StringDictionary<T> = Dictionary<String, T>\n",
|
||||
"typealias BackwardTriple<T1, T2, T3> = (T3, T2, T1)\n",
|
||||
"typealias DictionaryOfStrings<T : Hashable> = Dictionary<T, String>\n"
|
||||
Example("func foo<T>() {}\n"),
|
||||
Example("func foo<T>() -> T {}\n"),
|
||||
Example("func foo<T, U>(param: U) -> T {}\n"),
|
||||
Example("func foo<T: Hashable, U: Rule>(param: U) -> T {}\n"),
|
||||
Example("struct Foo<T> {}\n"),
|
||||
Example("class Foo<T> {}\n"),
|
||||
Example("enum Foo<T> {}\n"),
|
||||
Example("func run(_ options: NoOptions<CommandantError<()>>) {}\n"),
|
||||
Example("func foo(_ options: Set<type>) {}\n"),
|
||||
Example("func < <T: Comparable>(lhs: T?, rhs: T?) -> Bool\n"),
|
||||
Example("func configureWith(data: Either<MessageThread, (project: Project, backing: Backing)>)\n"),
|
||||
Example("typealias StringDictionary<T> = Dictionary<String, T>\n"),
|
||||
Example("typealias BackwardTriple<T1, T2, T3> = (T3, T2, T1)\n"),
|
||||
Example("typealias DictionaryOfStrings<T : Hashable> = Dictionary<T, String>\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"func foo<↓T_Foo>() {}\n",
|
||||
"func foo<T, ↓U_Foo>(param: U_Foo) -> T {}\n",
|
||||
"func foo<↓\(String(repeating: "T", count: 21))>() {}\n",
|
||||
"func foo<↓type>() {}\n",
|
||||
"typealias StringDictionary<↓T_Foo> = Dictionary<String, T_Foo>\n",
|
||||
"typealias BackwardTriple<T1, ↓T2_Bar, T3> = (T3, T2_Bar, T1)\n",
|
||||
"typealias DictionaryOfStrings<↓T_Foo: Hashable> = Dictionary<T_Foo, String>\n"
|
||||
Example("func foo<↓T_Foo>() {}\n"),
|
||||
Example("func foo<T, ↓U_Foo>(param: U_Foo) -> T {}\n"),
|
||||
Example("func foo<↓\(String(repeating: "T", count: 21))>() {}\n"),
|
||||
Example("func foo<↓type>() {}\n"),
|
||||
Example("typealias StringDictionary<↓T_Foo> = Dictionary<String, T_Foo>\n"),
|
||||
Example("typealias BackwardTriple<T1, ↓T2_Bar, T3> = (T3, T2_Bar, T1)\n"),
|
||||
Example("typealias DictionaryOfStrings<↓T_Foo: Hashable> = Dictionary<T_Foo, String>\n")
|
||||
] + ["class", "struct", "enum"].flatMap { type -> [Example] in
|
||||
return [
|
||||
"\(type) Foo<↓T_Foo> {}\n",
|
||||
"\(type) Foo<T, ↓U_Foo> {}\n",
|
||||
"\(type) Foo<↓T_Foo, ↓U_Foo> {}\n",
|
||||
"\(type) Foo<↓\(String(repeating: "T", count: 21))> {}\n",
|
||||
"\(type) Foo<↓type> {}\n"
|
||||
Example("\(type) Foo<↓T_Foo> {}\n"),
|
||||
Example("\(type) Foo<T, ↓U_Foo> {}\n"),
|
||||
Example("\(type) Foo<↓T_Foo, ↓U_Foo> {}\n"),
|
||||
Example("\(type) Foo<↓\(String(repeating: "T", count: 21))> {}\n"),
|
||||
Example("\(type) Foo<↓type> {}\n")
|
||||
]
|
||||
}
|
||||
)
|
||||
|
||||
@@ -9,14 +9,14 @@ struct IsDisjointRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
description: "Prefer using `Set.isDisjoint(with:)` over `Set.intersection(_:).isEmpty`",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"_ = Set(syntaxKinds).isDisjoint(with: commentAndStringKindsSet)",
|
||||
"let isObjc = !objcAttributes.isDisjoint(with: dictionary.enclosedSwiftAttributes)",
|
||||
"_ = Set(syntaxKinds).intersection(commentAndStringKindsSet)",
|
||||
"_ = !objcAttributes.intersection(dictionary.enclosedSwiftAttributes)"
|
||||
Example("_ = Set(syntaxKinds).isDisjoint(with: commentAndStringKindsSet)"),
|
||||
Example("let isObjc = !objcAttributes.isDisjoint(with: dictionary.enclosedSwiftAttributes)"),
|
||||
Example("_ = Set(syntaxKinds).intersection(commentAndStringKindsSet)"),
|
||||
Example("_ = !objcAttributes.intersection(dictionary.enclosedSwiftAttributes)")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"_ = Set(syntaxKinds).↓intersection(commentAndStringKindsSet).isEmpty",
|
||||
"let isObjc = !objcAttributes.↓intersection(dictionary.enclosedSwiftAttributes).isEmpty"
|
||||
Example("_ = Set(syntaxKinds).↓intersection(commentAndStringKindsSet).isEmpty"),
|
||||
Example("let isObjc = !objcAttributes.↓intersection(dictionary.enclosedSwiftAttributes).isEmpty")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,14 +9,14 @@ struct LegacyRandomRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
description: "Prefer using `type.random(in:)` over legacy functions",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"Int.random(in: 0..<10)\n",
|
||||
"Double.random(in: 8.6...111.34)\n",
|
||||
"Float.random(in: 0 ..< 1)\n"
|
||||
Example("Int.random(in: 0..<10)\n"),
|
||||
Example("Double.random(in: 8.6...111.34)\n"),
|
||||
Example("Float.random(in: 0 ..< 1)\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓arc4random()\n",
|
||||
"↓arc4random_uniform(83)\n",
|
||||
"↓drand48()\n"
|
||||
Example("↓arc4random()\n"),
|
||||
Example("↓arc4random_uniform(83)\n"),
|
||||
Example("↓drand48()\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,15 +9,15 @@ struct NoExtensionAccessModifierRule: SwiftSyntaxRule, OptInRule, ConfigurationP
|
||||
description: "Prefer not to use extension access modifiers",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"extension String {}",
|
||||
"\n\n extension String {}"
|
||||
Example("extension String {}"),
|
||||
Example("\n\n extension String {}")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓private extension String {}",
|
||||
"↓public \n extension String {}",
|
||||
"↓open extension String {}",
|
||||
"↓internal extension String {}",
|
||||
"↓fileprivate extension String {}"
|
||||
Example("↓private extension String {}"),
|
||||
Example("↓public \n extension String {}"),
|
||||
Example("↓open extension String {}"),
|
||||
Example("↓internal extension String {}"),
|
||||
Example("↓fileprivate extension String {}")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,15 +9,15 @@ struct NoGroupingExtensionRule: OptInRule, ConfigurationProviderRule {
|
||||
description: "Extensions shouldn't be used to group code within the same source file",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"protocol Food {}\nextension Food {}\n",
|
||||
"class Apples {}\nextension Oranges {}\n",
|
||||
"class Box<T> {}\nextension Box where T: Vegetable {}\n"
|
||||
Example("protocol Food {}\nextension Food {}\n"),
|
||||
Example("class Apples {}\nextension Oranges {}\n"),
|
||||
Example("class Box<T> {}\nextension Box where T: Vegetable {}\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"enum Fruit {}\n↓extension Fruit {}\n",
|
||||
"↓extension Tea: Error {}\nstruct Tea {}\n",
|
||||
"class Ham { class Spam {}}\n↓extension Ham.Spam {}\n",
|
||||
"extension External { struct Gotcha {}}\n↓extension External.Gotcha {}\n"
|
||||
Example("enum Fruit {}\n↓extension Fruit {}\n"),
|
||||
Example("↓extension Tea: Error {}\nstruct Tea {}\n"),
|
||||
Example("class Ham { class Spam {}}\n↓extension Ham.Spam {}\n"),
|
||||
Example("extension External { struct Gotcha {}}\n↓extension External.Gotcha {}\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,27 +9,27 @@ struct PatternMatchingKeywordsRule: SwiftSyntaxRule, ConfigurationProviderRule,
|
||||
description: "Combine multiple pattern matching bindings by moving keywords out of tuples",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"default",
|
||||
"case 1",
|
||||
"case bar",
|
||||
"case let (x, y)",
|
||||
"case .foo(let x)",
|
||||
"case let .foo(x, y)",
|
||||
"case .foo(let x), .bar(let x)",
|
||||
"case .foo(let x, var y)",
|
||||
"case var (x, y)",
|
||||
"case .foo(var x)",
|
||||
"case var .foo(x, y)"
|
||||
Example("default"),
|
||||
Example("case 1"),
|
||||
Example("case bar"),
|
||||
Example("case let (x, y)"),
|
||||
Example("case .foo(let x)"),
|
||||
Example("case let .foo(x, y)"),
|
||||
Example("case .foo(let x), .bar(let x)"),
|
||||
Example("case .foo(let x, var y)"),
|
||||
Example("case var (x, y)"),
|
||||
Example("case .foo(var x)"),
|
||||
Example("case var .foo(x, y)")
|
||||
].map(wrapInSwitch),
|
||||
triggeringExamples: [
|
||||
"case (↓let x, ↓let y)",
|
||||
"case (↓let x, ↓let y, .foo)",
|
||||
"case (↓let x, ↓let y, _)",
|
||||
"case .foo(↓let x, ↓let y)",
|
||||
"case (.yamlParsing(↓let x), .yamlParsing(↓let y))",
|
||||
"case (↓var x, ↓var y)",
|
||||
"case .foo(↓var x, ↓var y)",
|
||||
"case (.yamlParsing(↓var x), .yamlParsing(↓var y))"
|
||||
Example("case (↓let x, ↓let y)"),
|
||||
Example("case (↓let x, ↓let y, .foo)"),
|
||||
Example("case (↓let x, ↓let y, _)"),
|
||||
Example("case .foo(↓let x, ↓let y)"),
|
||||
Example("case (.yamlParsing(↓let x), .yamlParsing(↓let y))"),
|
||||
Example("case (↓var x, ↓var y)"),
|
||||
Example("case .foo(↓var x, ↓var y)"),
|
||||
Example("case (.yamlParsing(↓var x), .yamlParsing(↓var y))")
|
||||
].map(wrapInSwitch)
|
||||
)
|
||||
|
||||
|
||||
@@ -9,16 +9,16 @@ struct PreferNimbleRule: SwiftSyntaxRule, OptInRule, ConfigurationProviderRule {
|
||||
description: "Prefer Nimble matchers over XCTAssert functions",
|
||||
kind: .idiomatic,
|
||||
nonTriggeringExamples: [
|
||||
"expect(foo) == 1",
|
||||
"expect(foo).to(equal(1))"
|
||||
Example("expect(foo) == 1"),
|
||||
Example("expect(foo).to(equal(1))")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓XCTAssertTrue(foo)",
|
||||
"↓XCTAssertEqual(foo, 2)",
|
||||
"↓XCTAssertNotEqual(foo, 2)",
|
||||
"↓XCTAssertNil(foo)",
|
||||
"↓XCTAssert(foo)",
|
||||
"↓XCTAssertGreaterThan(foo, 10)"
|
||||
Example("↓XCTAssertTrue(foo)"),
|
||||
Example("↓XCTAssertEqual(foo, 2)"),
|
||||
Example("↓XCTAssertNotEqual(foo, 2)"),
|
||||
Example("↓XCTAssertNil(foo)"),
|
||||
Example("↓XCTAssert(foo)"),
|
||||
Example("↓XCTAssertGreaterThan(foo, 10)")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -1,56 +1,56 @@
|
||||
internal struct XCTSpecificMatcherRuleExamples {
|
||||
static let nonTriggeringExamples: [Example] = [
|
||||
static let nonTriggeringExamples = [
|
||||
// True/False
|
||||
"XCTAssert(foo)",
|
||||
"XCTAssertFalse(foo)",
|
||||
"XCTAssertTrue(foo)",
|
||||
Example("XCTAssert(foo"),
|
||||
Example("XCTAssertFalse(foo)"),
|
||||
Example("XCTAssertTrue(foo)"),
|
||||
|
||||
// Nil/Not nil
|
||||
"XCTAssertNil(foo)",
|
||||
"XCTAssertNotNil(foo)",
|
||||
Example("XCTAssertNil(foo)"),
|
||||
Example("XCTAssertNotNil(foo)"),
|
||||
|
||||
// Equal/Not equal
|
||||
"XCTAssertEqual(foo, 2)",
|
||||
"XCTAssertNotEqual(foo, \"false\")",
|
||||
Example("XCTAssertEqual(foo, 2)"),
|
||||
Example("XCTAssertNotEqual(foo, \"false\")"),
|
||||
|
||||
// Arrays with key words
|
||||
"XCTAssertEqual(foo, [1, 2, 3, true])",
|
||||
"XCTAssertEqual(foo, [1, 2, 3, false])",
|
||||
"XCTAssertEqual(foo, [1, 2, 3, nil])",
|
||||
"XCTAssertEqual(foo, [true, nil, true, nil])",
|
||||
"XCTAssertEqual([1, 2, 3, true], foo)",
|
||||
"XCTAssertEqual([1, 2, 3, false], foo)",
|
||||
"XCTAssertEqual([1, 2, 3, nil], foo)",
|
||||
"XCTAssertEqual([true, nil, true, nil], foo)",
|
||||
Example("XCTAssertEqual(foo, [1, 2, 3, true])"),
|
||||
Example("XCTAssertEqual(foo, [1, 2, 3, false])"),
|
||||
Example("XCTAssertEqual(foo, [1, 2, 3, nil])"),
|
||||
Example("XCTAssertEqual(foo, [true, nil, true, nil])"),
|
||||
Example("XCTAssertEqual([1, 2, 3, true], foo)"),
|
||||
Example("XCTAssertEqual([1, 2, 3, false], foo)"),
|
||||
Example("XCTAssertEqual([1, 2, 3, nil], foo)"),
|
||||
Example("XCTAssertEqual([true, nil, true, nil], foo)"),
|
||||
|
||||
// Inverted logic
|
||||
"XCTAssertEqual(2, foo)",
|
||||
"XCTAssertNotEqual(\"false\"), foo)",
|
||||
"XCTAssertEqual(false, foo?.bar)",
|
||||
"XCTAssertEqual(true, foo?.bar)",
|
||||
Example("XCTAssertEqual(2, foo)"),
|
||||
Example("XCTAssertNotEqual(\"false\"), foo)"),
|
||||
Example("XCTAssertEqual(false, foo?.bar)"),
|
||||
Example("XCTAssertEqual(true, foo?.bar)"),
|
||||
|
||||
// Blank spaces
|
||||
"XCTAssert( foo )",
|
||||
"XCTAssertFalse( foo )",
|
||||
"XCTAssertTrue( foo )",
|
||||
"XCTAssertNil( foo )",
|
||||
"XCTAssertNotNil( foo )",
|
||||
"XCTAssertEqual( foo , 2 )",
|
||||
"XCTAssertNotEqual( foo, \"false\")",
|
||||
Example("XCTAssert( foo )"),
|
||||
Example("XCTAssertFalse( foo )"),
|
||||
Example("XCTAssertTrue( foo )"),
|
||||
Example("XCTAssertNil( foo )"),
|
||||
Example("XCTAssertNotNil( foo )"),
|
||||
Example("XCTAssertEqual( foo , 2 )"),
|
||||
Example("XCTAssertNotEqual( foo, \"false\")"),
|
||||
|
||||
// Optionals
|
||||
"XCTAssertEqual(foo?.bar, false)",
|
||||
"XCTAssertEqual(foo?.bar, true)",
|
||||
"XCTAssertNil(foo?.bar)",
|
||||
"XCTAssertNotNil(foo?.bar)",
|
||||
"XCTAssertEqual(foo?.bar, 2)",
|
||||
"XCTAssertNotEqual(foo?.bar, \"false\")",
|
||||
Example("XCTAssertEqual(foo?.bar, false)"),
|
||||
Example("XCTAssertEqual(foo?.bar, true)"),
|
||||
Example("XCTAssertNil(foo?.bar)"),
|
||||
Example("XCTAssertNotNil(foo?.bar)"),
|
||||
Example("XCTAssertEqual(foo?.bar, 2)"),
|
||||
Example("XCTAssertNotEqual(foo?.bar, \"false\")"),
|
||||
|
||||
// Function calls and enums
|
||||
"XCTAssertEqual(foo?.bar, toto())",
|
||||
"XCTAssertEqual(foo?.bar, .toto(.zoo))",
|
||||
"XCTAssertEqual(toto(), foo?.bar)",
|
||||
"XCTAssertEqual(.toto(.zoo), foo?.bar)",
|
||||
Example("XCTAssertEqual(foo?.bar, toto())"),
|
||||
Example("XCTAssertEqual(foo?.bar, .toto(.zoo))"),
|
||||
Example("XCTAssertEqual(toto(), foo?.bar)"),
|
||||
Example("XCTAssertEqual(.toto(.zoo), foo?.bar)"),
|
||||
|
||||
// Configurations Disabled
|
||||
Example("XCTAssertEqual(foo, true)",
|
||||
@@ -61,81 +61,81 @@ internal struct XCTSpecificMatcherRuleExamples {
|
||||
excludeFromDocumentation: true),
|
||||
|
||||
// Skip if one operand might be a type or a tuple
|
||||
"XCTAssert(foo.self == bar)",
|
||||
"XCTAssertTrue(type(of: foo) != Int.self)",
|
||||
"XCTAssertTrue(a == (1, 3, 5)"
|
||||
Example("XCTAssert(foo.self == bar)"),
|
||||
Example("XCTAssertTrue(type(of: foo) != Int.self)"),
|
||||
Example("XCTAssertTrue(a == (1, 3, 5)")
|
||||
]
|
||||
|
||||
static let triggeringExamples: [Example] = [
|
||||
static let triggeringExamples = [
|
||||
// Without message
|
||||
"↓XCTAssertEqual(foo, true)",
|
||||
"↓XCTAssertEqual(foo, false)",
|
||||
"↓XCTAssertEqual(foo, nil)",
|
||||
"↓XCTAssertNotEqual(foo, true)",
|
||||
"↓XCTAssertNotEqual(foo, false)",
|
||||
"↓XCTAssertNotEqual(foo, nil)",
|
||||
Example("↓XCTAssertEqual(foo, true)"),
|
||||
Example("↓XCTAssertEqual(foo, false)"),
|
||||
Example("↓XCTAssertEqual(foo, nil)"),
|
||||
Example("↓XCTAssertNotEqual(foo, true)"),
|
||||
Example("↓XCTAssertNotEqual(foo, false)"),
|
||||
Example("↓XCTAssertNotEqual(foo, nil)"),
|
||||
|
||||
// Inverted logic (just in case...)
|
||||
"↓XCTAssertEqual(true, foo)",
|
||||
"↓XCTAssertEqual(false, foo)",
|
||||
"↓XCTAssertEqual(nil, foo)",
|
||||
"↓XCTAssertNotEqual(true, foo)",
|
||||
"↓XCTAssertNotEqual(false, foo)",
|
||||
"↓XCTAssertNotEqual(nil, foo)",
|
||||
Example("↓XCTAssertEqual(true, foo)"),
|
||||
Example("↓XCTAssertEqual(false, foo)"),
|
||||
Example("↓XCTAssertEqual(nil, foo)"),
|
||||
Example("↓XCTAssertNotEqual(true, foo)"),
|
||||
Example("↓XCTAssertNotEqual(false, foo)"),
|
||||
Example("↓XCTAssertNotEqual(nil, foo)"),
|
||||
|
||||
// With message
|
||||
"↓XCTAssertEqual(foo, true, \"toto\")",
|
||||
"↓XCTAssertEqual(foo, false, \"toto\")",
|
||||
"↓XCTAssertEqual(foo, nil, \"toto\")",
|
||||
"↓XCTAssertNotEqual(foo, true, \"toto\")",
|
||||
"↓XCTAssertNotEqual(foo, false, \"toto\")",
|
||||
"↓XCTAssertNotEqual(foo, nil, \"toto\")",
|
||||
"↓XCTAssertEqual(true, foo, \"toto\")",
|
||||
"↓XCTAssertEqual(false, foo, \"toto\")",
|
||||
"↓XCTAssertEqual(nil, foo, \"toto\")",
|
||||
"↓XCTAssertNotEqual(true, foo, \"toto\")",
|
||||
"↓XCTAssertNotEqual(false, foo, \"toto\")",
|
||||
"↓XCTAssertNotEqual(nil, foo, \"toto\")",
|
||||
Example("↓XCTAssertEqual(foo, true, \"toto\")"),
|
||||
Example("↓XCTAssertEqual(foo, false, \"toto\")"),
|
||||
Example("↓XCTAssertEqual(foo, nil, \"toto\")"),
|
||||
Example("↓XCTAssertNotEqual(foo, true, \"toto\")"),
|
||||
Example("↓XCTAssertNotEqual(foo, false, \"toto\")"),
|
||||
Example("↓XCTAssertNotEqual(foo, nil, \"toto\")"),
|
||||
Example("↓XCTAssertEqual(true, foo, \"toto\")"),
|
||||
Example("↓XCTAssertEqual(false, foo, \"toto\")"),
|
||||
Example("↓XCTAssertEqual(nil, foo, \"toto\")"),
|
||||
Example("↓XCTAssertNotEqual(true, foo, \"toto\")"),
|
||||
Example("↓XCTAssertNotEqual(false, foo, \"toto\")"),
|
||||
Example("↓XCTAssertNotEqual(nil, foo, \"toto\")"),
|
||||
|
||||
// Blank spaces
|
||||
"↓XCTAssertEqual(foo,true)",
|
||||
"↓XCTAssertEqual( foo , false )",
|
||||
"↓XCTAssertEqual( foo , nil )",
|
||||
Example("↓XCTAssertEqual(foo,true)"),
|
||||
Example("↓XCTAssertEqual( foo , false )"),
|
||||
Example("↓XCTAssertEqual( foo , nil )"),
|
||||
|
||||
// Arrays
|
||||
"↓XCTAssertEqual(true, [1, 2, 3, true].hasNumbers())",
|
||||
"↓XCTAssertEqual([1, 2, 3, true].hasNumbers(), true)",
|
||||
Example("↓XCTAssertEqual(true, [1, 2, 3, true].hasNumbers())"),
|
||||
Example("↓XCTAssertEqual([1, 2, 3, true].hasNumbers(), true)"),
|
||||
|
||||
// Optionals
|
||||
"↓XCTAssertEqual(foo?.bar, nil)",
|
||||
"↓XCTAssertNotEqual(foo?.bar, nil)",
|
||||
Example("↓XCTAssertEqual(foo?.bar, nil)"),
|
||||
Example("↓XCTAssertNotEqual(foo?.bar, nil)"),
|
||||
|
||||
// Weird cases
|
||||
"↓XCTAssertEqual(nil, true)",
|
||||
"↓XCTAssertEqual(nil, false)",
|
||||
"↓XCTAssertEqual(true, nil)",
|
||||
"↓XCTAssertEqual(false, nil)",
|
||||
"↓XCTAssertEqual(nil, nil)",
|
||||
"↓XCTAssertEqual(true, true)",
|
||||
"↓XCTAssertEqual(false, false)",
|
||||
Example("↓XCTAssertEqual(nil, true)"),
|
||||
Example("↓XCTAssertEqual(nil, false)"),
|
||||
Example("↓XCTAssertEqual(true, nil)"),
|
||||
Example("↓XCTAssertEqual(false, nil)"),
|
||||
Example("↓XCTAssertEqual(nil, nil)"),
|
||||
Example("↓XCTAssertEqual(true, true)"),
|
||||
Example("↓XCTAssertEqual(false, false)"),
|
||||
|
||||
// Equality with `==`
|
||||
"↓XCTAssert(foo == bar)",
|
||||
"↓XCTAssertTrue( foo == bar )",
|
||||
"↓XCTAssertFalse(1 == foo)",
|
||||
"↓XCTAssert(foo == bar, \"toto\")",
|
||||
Example("↓XCTAssert(foo == bar)"),
|
||||
Example("↓XCTAssertTrue( foo == bar )"),
|
||||
Example("↓XCTAssertFalse(1 == foo)"),
|
||||
Example("↓XCTAssert(foo == bar, \"toto\")"),
|
||||
|
||||
// Inequality with `!=`
|
||||
"↓XCTAssert(foo != bar)",
|
||||
"↓XCTAssertTrue( foo != bar )",
|
||||
"↓XCTAssertFalse(1 != foo)",
|
||||
"↓XCTAssert(foo != bar, \"toto\")",
|
||||
Example("↓XCTAssert(foo != bar)"),
|
||||
Example("↓XCTAssertTrue( foo != bar )"),
|
||||
Example("↓XCTAssertFalse(1 != foo)"),
|
||||
Example("↓XCTAssert(foo != bar, \"toto\")"),
|
||||
|
||||
// Comparison with `nil`
|
||||
"↓XCTAssert( foo == nil)",
|
||||
"↓XCTAssert(nil == foo",
|
||||
"↓XCTAssertTrue( foo != nil)",
|
||||
"↓XCTAssertFalse(nil != foo",
|
||||
"↓XCTAssert(foo == nil, \"toto\")"
|
||||
Example("↓XCTAssert( foo == nil)"),
|
||||
Example("↓XCTAssert(nil == foo"),
|
||||
Example("↓XCTAssertTrue( foo != nil)"),
|
||||
Example("↓XCTAssertFalse(nil != foo"),
|
||||
Example("↓XCTAssert(foo == nil, \"toto\")")
|
||||
]
|
||||
}
|
||||
|
||||
@@ -9,23 +9,23 @@ struct ClassDelegateProtocolRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
description: "Delegate protocols should be class-only so they can be weakly referenced",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"protocol FooDelegate: class {}\n",
|
||||
"protocol FooDelegate: class, BarDelegate {}\n",
|
||||
"protocol Foo {}\n",
|
||||
"class FooDelegate {}\n",
|
||||
"@objc protocol FooDelegate {}\n",
|
||||
"@objc(MyFooDelegate)\n protocol FooDelegate {}\n",
|
||||
"protocol FooDelegate: BarDelegate {}\n",
|
||||
"protocol FooDelegate: AnyObject {}\n",
|
||||
"protocol FooDelegate: NSObjectProtocol {}\n",
|
||||
"protocol FooDelegate where Self: BarDelegate {}\n",
|
||||
"protocol FooDelegate where Self: AnyObject {}\n",
|
||||
"protocol FooDelegate where Self: NSObjectProtocol {}\n"
|
||||
Example("protocol FooDelegate: class {}\n"),
|
||||
Example("protocol FooDelegate: class, BarDelegate {}\n"),
|
||||
Example("protocol Foo {}\n"),
|
||||
Example("class FooDelegate {}\n"),
|
||||
Example("@objc protocol FooDelegate {}\n"),
|
||||
Example("@objc(MyFooDelegate)\n protocol FooDelegate {}\n"),
|
||||
Example("protocol FooDelegate: BarDelegate {}\n"),
|
||||
Example("protocol FooDelegate: AnyObject {}\n"),
|
||||
Example("protocol FooDelegate: NSObjectProtocol {}\n"),
|
||||
Example("protocol FooDelegate where Self: BarDelegate {}\n"),
|
||||
Example("protocol FooDelegate where Self: AnyObject {}\n"),
|
||||
Example("protocol FooDelegate where Self: NSObjectProtocol {}\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓protocol FooDelegate {}\n",
|
||||
"↓protocol FooDelegate: Bar {}\n",
|
||||
"↓protocol FooDelegate where Self: StringProtocol {}\n"
|
||||
Example("↓protocol FooDelegate {}\n"),
|
||||
Example("↓protocol FooDelegate: Bar {}\n"),
|
||||
Example("↓protocol FooDelegate where Self: StringProtocol {}\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -10,14 +10,14 @@ struct CompilerProtocolInitRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
"shouldn't be called directly.",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"let set: Set<Int> = [1, 2]\n",
|
||||
"let set = Set(array)\n"
|
||||
Example("let set: Set<Int> = [1, 2]\n"),
|
||||
Example("let set = Set(array)\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"let set = ↓Set(arrayLiteral: 1, 2)\n",
|
||||
"let set = ↓Set (arrayLiteral: 1, 2)\n",
|
||||
"let set = ↓Set.init(arrayLiteral: 1, 2)\n",
|
||||
"let set = ↓Set.init(arrayLiteral : 1, 2)\n"
|
||||
Example("let set = ↓Set(arrayLiteral: 1, 2)\n"),
|
||||
Example("let set = ↓Set (arrayLiteral: 1, 2)\n"),
|
||||
Example("let set = ↓Set.init(arrayLiteral: 1, 2)\n"),
|
||||
Example("let set = ↓Set.init(arrayLiteral : 1, 2)\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -1,37 +1,37 @@
|
||||
internal enum DeploymentTargetRuleExamples {
|
||||
static let nonTriggeringExamples: [Example] = [
|
||||
"@available(iOS 12.0, *)\nclass A {}",
|
||||
"@available(iOSApplicationExtension 13.0, *)\nclass A {}",
|
||||
"@available(watchOS 4.0, *)\nclass A {}",
|
||||
"@available(watchOSApplicationExtension 4.0, *)\nclass A {}",
|
||||
"@available(swift 3.0.2)\nclass A {}",
|
||||
"class A {}",
|
||||
"if #available(iOS 10.0, *) {}",
|
||||
"if #available(iOS 10, *) {}",
|
||||
"guard #available(iOS 12.0, *) else { return }",
|
||||
"#if #unavailable(iOS 15.0) {}",
|
||||
"#guard #unavailable(iOS 15.0) {} else { return }"
|
||||
Example("@available(iOS 12.0, *)\nclass A {}"),
|
||||
Example("@available(iOSApplicationExtension 13.0, *)\nclass A {}"),
|
||||
Example("@available(watchOS 4.0, *)\nclass A {}"),
|
||||
Example("@available(watchOSApplicationExtension 4.0, *)\nclass A {}"),
|
||||
Example("@available(swift 3.0.2)\nclass A {}"),
|
||||
Example("class A {}"),
|
||||
Example("if #available(iOS 10.0, *) {}"),
|
||||
Example("if #available(iOS 10, *) {}"),
|
||||
Example("guard #available(iOS 12.0, *) else { return }"),
|
||||
Example("#if #unavailable(iOS 15.0) {}"),
|
||||
Example("#guard #unavailable(iOS 15.0) {} else { return }")
|
||||
]
|
||||
|
||||
static let triggeringExamples: [Example] = [
|
||||
"↓@available(iOS 6.0, *)\nclass A {}",
|
||||
"↓@available(iOSApplicationExtension 6.0, *)\nclass A {}",
|
||||
"↓@available(iOS 7.0, *)\nclass A {}",
|
||||
"↓@available(iOS 6, *)\nclass A {}",
|
||||
"↓@available(iOS 6.0, macOS 10.12, *)\n class A {}",
|
||||
"↓@available(macOS 10.12, iOS 6.0, *)\n class A {}",
|
||||
"↓@available(macOS 10.7, *)\nclass A {}",
|
||||
"↓@available(macOSApplicationExtension 10.7, *)\nclass A {}",
|
||||
"↓@available(OSX 10.7, *)\nclass A {}",
|
||||
"↓@available(watchOS 0.9, *)\nclass A {}",
|
||||
"↓@available(watchOSApplicationExtension 0.9, *)\nclass A {}",
|
||||
"↓@available(tvOS 8, *)\nclass A {}",
|
||||
"↓@available(tvOSApplicationExtension 8, *)\nclass A {}",
|
||||
"if ↓#available(iOS 6.0, *) {}",
|
||||
"if ↓#available(iOS 6, *) {}",
|
||||
"guard ↓#available(iOS 6.0, *) else { return }",
|
||||
"if ↓#unavailable(iOS 7.0) {}",
|
||||
"if ↓#unavailable(iOS 6.9) {}",
|
||||
"guard ↓#unavailable(iOS 7.0) {} else { return }"
|
||||
Example("↓@available(iOS 6.0, *)\nclass A {}"),
|
||||
Example("↓@available(iOSApplicationExtension 6.0, *)\nclass A {}"),
|
||||
Example("↓@available(iOS 7.0, *)\nclass A {}"),
|
||||
Example("↓@available(iOS 6, *)\nclass A {}"),
|
||||
Example("↓@available(iOS 6.0, macOS 10.12, *)\n class A {}"),
|
||||
Example("↓@available(macOS 10.12, iOS 6.0, *)\n class A {}"),
|
||||
Example("↓@available(macOS 10.7, *)\nclass A {}"),
|
||||
Example("↓@available(macOSApplicationExtension 10.7, *)\nclass A {}"),
|
||||
Example("↓@available(OSX 10.7, *)\nclass A {}"),
|
||||
Example("↓@available(watchOS 0.9, *)\nclass A {}"),
|
||||
Example("↓@available(watchOSApplicationExtension 0.9, *)\nclass A {}"),
|
||||
Example("↓@available(tvOS 8, *)\nclass A {}"),
|
||||
Example("↓@available(tvOSApplicationExtension 8, *)\nclass A {}"),
|
||||
Example("if ↓#available(iOS 6.0, *) {}"),
|
||||
Example("if ↓#available(iOS 6, *) {}"),
|
||||
Example("guard ↓#available(iOS 6.0, *) else { return }"),
|
||||
Example("if ↓#unavailable(iOS 7.0) {}"),
|
||||
Example("if ↓#unavailable(iOS 6.9) {}"),
|
||||
Example("guard ↓#unavailable(iOS 7.0) {} else { return }")
|
||||
]
|
||||
}
|
||||
|
||||
@@ -9,29 +9,29 @@ struct DiscouragedDirectInitRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
description: "Discouraged direct initialization of types that can be harmful",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"let foo = UIDevice.current",
|
||||
"let foo = Bundle.main",
|
||||
"let foo = Bundle(path: \"bar\")",
|
||||
"let foo = Bundle(identifier: \"bar\")",
|
||||
"let foo = Bundle.init(path: \"bar\")",
|
||||
"let foo = Bundle.init(identifier: \"bar\")",
|
||||
"let foo = NSError(domain: \"bar\", code: 0)",
|
||||
"let foo = NSError.init(domain: \"bar\", code: 0)",
|
||||
"func testNSError()"
|
||||
Example("let foo = UIDevice.current"),
|
||||
Example("let foo = Bundle.main"),
|
||||
Example("let foo = Bundle(path: \"bar\")"),
|
||||
Example("let foo = Bundle(identifier: \"bar\")"),
|
||||
Example("let foo = Bundle.init(path: \"bar\")"),
|
||||
Example("let foo = Bundle.init(identifier: \"bar\")"),
|
||||
Example("let foo = NSError(domain: \"bar\", code: 0)"),
|
||||
Example("let foo = NSError.init(domain: \"bar\", code: 0)"),
|
||||
Example("func testNSError()")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓UIDevice()",
|
||||
"↓Bundle()",
|
||||
"let foo = ↓UIDevice()",
|
||||
"let foo = ↓Bundle()",
|
||||
"let foo = ↓NSError()",
|
||||
"let foo = bar(bundle: ↓Bundle(), device: ↓UIDevice(), error: ↓NSError())",
|
||||
"↓UIDevice.init()",
|
||||
"↓Bundle.init()",
|
||||
"↓NSError.init()",
|
||||
"let foo = ↓UIDevice.init()",
|
||||
"let foo = ↓Bundle.init()",
|
||||
"let foo = bar(bundle: ↓Bundle.init(), device: ↓UIDevice.init(), error: ↓NSError.init())"
|
||||
Example("↓UIDevice()"),
|
||||
Example("↓Bundle()"),
|
||||
Example("let foo = ↓UIDevice()"),
|
||||
Example("let foo = ↓Bundle()"),
|
||||
Example("let foo = ↓NSError()"),
|
||||
Example("let foo = bar(bundle: ↓Bundle(), device: ↓UIDevice(), error: ↓NSError())"),
|
||||
Example("↓UIDevice.init()"),
|
||||
Example("↓Bundle.init()"),
|
||||
Example("↓NSError.init()"),
|
||||
Example("let foo = ↓UIDevice.init()"),
|
||||
Example("let foo = ↓Bundle.init()"),
|
||||
Example("let foo = bar(bundle: ↓Bundle.init(), device: ↓UIDevice.init(), error: ↓NSError.init())")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,16 +9,16 @@ struct DynamicInlineRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
description: "Avoid using 'dynamic' and '@inline(__always)' together",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"class C {\ndynamic func f() {}}",
|
||||
"class C {\n@inline(__always) func f() {}}",
|
||||
"class C {\n@inline(never) dynamic func f() {}}"
|
||||
Example("class C {\ndynamic func f() {}}"),
|
||||
Example("class C {\n@inline(__always) func f() {}}"),
|
||||
Example("class C {\n@inline(never) dynamic func f() {}}")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"class C {\n@inline(__always) dynamic ↓func f() {}\n}",
|
||||
"class C {\n@inline(__always) public dynamic ↓func f() {}\n}",
|
||||
"class C {\n@inline(__always) dynamic internal ↓func f() {}\n}",
|
||||
"class C {\n@inline(__always)\ndynamic ↓func f() {}\n}",
|
||||
"class C {\n@inline(__always)\ndynamic\n↓func f() {}\n}"
|
||||
Example("class C {\n@inline(__always) dynamic ↓func f() {}\n}"),
|
||||
Example("class C {\n@inline(__always) public dynamic ↓func f() {}\n}"),
|
||||
Example("class C {\n@inline(__always) dynamic internal ↓func f() {}\n}"),
|
||||
Example("class C {\n@inline(__always)\ndynamic ↓func f() {}\n}"),
|
||||
Example("class C {\n@inline(__always)\ndynamic\n↓func f() {}\n}")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -25,22 +25,22 @@ struct ExpiringTodoRule: ConfigurationProviderRule, OptInRule {
|
||||
description: "TODOs and FIXMEs should be resolved prior to their expiry date.",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"// notaTODO:\n",
|
||||
"// notaFIXME:\n",
|
||||
"// TODO: [12/31/9999]\n",
|
||||
"// TODO(note)\n",
|
||||
"// FIXME(note)\n",
|
||||
"/* FIXME: */\n",
|
||||
"/* TODO: */\n",
|
||||
"/** FIXME: */\n",
|
||||
"/** TODO: */\n"
|
||||
Example("// notaTODO:\n"),
|
||||
Example("// notaFIXME:\n"),
|
||||
Example("// TODO: [12/31/9999]\n"),
|
||||
Example("// TODO(note)\n"),
|
||||
Example("// FIXME(note)\n"),
|
||||
Example("/* FIXME: */\n"),
|
||||
Example("/* TODO: */\n"),
|
||||
Example("/** FIXME: */\n"),
|
||||
Example("/** TODO: */\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"// TODO: [↓10/14/2019]\n",
|
||||
"// FIXME: [↓10/14/2019]\n",
|
||||
"// FIXME: [↓1/14/2019]\n",
|
||||
"// FIXME: [↓10/14/2019]\n",
|
||||
"// TODO: [↓9999/14/10]\n"
|
||||
Example("// TODO: [↓10/14/2019]\n"),
|
||||
Example("// FIXME: [↓10/14/2019]\n"),
|
||||
Example("// FIXME: [↓1/14/2019]\n"),
|
||||
Example("// FIXME: [↓10/14/2019]\n"),
|
||||
Example("// TODO: [↓9999/14/10]\n")
|
||||
].skipWrappingInCommentTests()
|
||||
)
|
||||
|
||||
|
||||
@@ -7,27 +7,27 @@ struct InvalidSwiftLintCommandRule: ConfigurationProviderRule {
|
||||
description: "swiftlint command does not have a valid action or modifier",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"// swiftlint:disable unused_import",
|
||||
"// swiftlint:enable unused_import",
|
||||
"// swiftlint:disable:next unused_import",
|
||||
"// swiftlint:disable:previous unused_import",
|
||||
"// swiftlint:disable:this unused_import"
|
||||
Example("// swiftlint:disable unused_import"),
|
||||
Example("// swiftlint:enable unused_import"),
|
||||
Example("// swiftlint:disable:next unused_import"),
|
||||
Example("// swiftlint:disable:previous unused_import"),
|
||||
Example("// swiftlint:disable:this unused_import")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"// swiftlint:",
|
||||
"// swiftlint: ",
|
||||
"// swiftlint::",
|
||||
"// swiftlint:: ",
|
||||
"// swiftlint:disable",
|
||||
"// swiftlint:dissable unused_import",
|
||||
"// swiftlint:enaaaable unused_import",
|
||||
"// swiftlint:disable:nxt unused_import",
|
||||
"// swiftlint:enable:prevus unused_import",
|
||||
"// swiftlint:enable:ths unused_import",
|
||||
"// swiftlint:enable",
|
||||
"// swiftlint:enable:",
|
||||
"// swiftlint:enable: ",
|
||||
"// swiftlint:disable: unused_import"
|
||||
Example("// swiftlint:"),
|
||||
Example("// swiftlint: "),
|
||||
Example("// swiftlint::"),
|
||||
Example("// swiftlint:: "),
|
||||
Example("// swiftlint:disable"),
|
||||
Example("// swiftlint:dissable unused_import"),
|
||||
Example("// swiftlint:enaaaable unused_import"),
|
||||
Example("// swiftlint:disable:nxt unused_import"),
|
||||
Example("// swiftlint:enable:prevus unused_import"),
|
||||
Example("// swiftlint:enable:ths unused_import"),
|
||||
Example("// swiftlint:enable"),
|
||||
Example("// swiftlint:enable:"),
|
||||
Example("// swiftlint:enable: "),
|
||||
Example("// swiftlint:disable: unused_import")
|
||||
].skipWrappingInCommentTests()
|
||||
)
|
||||
|
||||
|
||||
@@ -9,25 +9,25 @@ struct PrivateActionRule: SwiftSyntaxRule, OptInRule, ConfigurationProviderRule
|
||||
description: "IBActions should be private",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"class Foo {\n\t@IBAction private func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"struct Foo {\n\t@IBAction private func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"class Foo {\n\t@IBAction fileprivate func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"struct Foo {\n\t@IBAction fileprivate func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"private extension Foo {\n\t@IBAction func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"fileprivate extension Foo {\n\t@IBAction func barButtonTapped(_ sender: UIButton) {}\n}\n"
|
||||
Example("class Foo {\n\t@IBAction private func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("struct Foo {\n\t@IBAction private func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("class Foo {\n\t@IBAction fileprivate func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("struct Foo {\n\t@IBAction fileprivate func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("private extension Foo {\n\t@IBAction func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("fileprivate extension Foo {\n\t@IBAction func barButtonTapped(_ sender: UIButton) {}\n}\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"class Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"struct Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"class Foo {\n\t@IBAction public ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"struct Foo {\n\t@IBAction public ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"class Foo {\n\t@IBAction internal ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"struct Foo {\n\t@IBAction internal ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"extension Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"extension Foo {\n\t@IBAction public ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"extension Foo {\n\t@IBAction internal ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"public extension Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n",
|
||||
"internal extension Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"
|
||||
Example("class Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("struct Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("class Foo {\n\t@IBAction public ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("struct Foo {\n\t@IBAction public ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("class Foo {\n\t@IBAction internal ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("struct Foo {\n\t@IBAction internal ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("extension Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("extension Foo {\n\t@IBAction public ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("extension Foo {\n\t@IBAction internal ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("public extension Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n"),
|
||||
Example("internal extension Foo {\n\t@IBAction ↓func barButtonTapped(_ sender: UIButton) {}\n}\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -10,18 +10,18 @@ struct TodoRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
description: "TODOs and FIXMEs should be resolved.",
|
||||
kind: .lint,
|
||||
nonTriggeringExamples: [
|
||||
"// notaTODO:\n",
|
||||
"// notaFIXME:\n"
|
||||
Example("// notaTODO:\n"),
|
||||
Example("// notaFIXME:\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"// ↓TODO:\n",
|
||||
"// ↓FIXME:\n",
|
||||
"// ↓TODO(note)\n",
|
||||
"// ↓FIXME(note)\n",
|
||||
"/* ↓FIXME: */\n",
|
||||
"/* ↓TODO: */\n",
|
||||
"/** ↓FIXME: */\n",
|
||||
"/** ↓TODO: */\n"
|
||||
Example("// ↓TODO:\n"),
|
||||
Example("// ↓FIXME:\n"),
|
||||
Example("// ↓TODO(note)\n"),
|
||||
Example("// ↓FIXME(note)\n"),
|
||||
Example("/* ↓FIXME: */\n"),
|
||||
Example("/* ↓TODO: */\n"),
|
||||
Example("/** ↓FIXME: */\n"),
|
||||
Example("/** ↓TODO: */\n")
|
||||
].skipWrappingInCommentTests()
|
||||
)
|
||||
|
||||
|
||||
@@ -1,56 +1,56 @@
|
||||
struct LargeTupleRuleExamples {
|
||||
static let nonTriggeringExamples: [Example] = [
|
||||
"let foo: (Int, Int)\n",
|
||||
"let foo: (start: Int, end: Int)\n",
|
||||
"let foo: (Int, (Int, String))\n",
|
||||
"func foo() -> (Int, Int)\n",
|
||||
"func foo() -> (Int, Int) {}\n",
|
||||
"func foo(bar: String) -> (Int, Int)\n",
|
||||
"func foo(bar: String) -> (Int, Int) {}\n",
|
||||
"func foo() throws -> (Int, Int)\n",
|
||||
"func foo() throws -> (Int, Int) {}\n",
|
||||
"let foo: (Int, Int, Int) -> Void\n",
|
||||
"let foo: (Int, Int, Int) throws -> Void\n",
|
||||
"func foo(bar: (Int, String, Float) -> Void)\n",
|
||||
"func foo(bar: (Int, String, Float) throws -> Void)\n",
|
||||
"var completionHandler: ((_ data: Data?, _ resp: URLResponse?, _ e: NSError?) -> Void)!\n",
|
||||
"func getDictionaryAndInt() -> (Dictionary<Int, String>, Int)?\n",
|
||||
"func getGenericTypeAndInt() -> (Type<Int, String, Float>, Int)?\n",
|
||||
"func foo() async -> (Int, Int)\n",
|
||||
"func foo() async -> (Int, Int) {}\n",
|
||||
"func foo(bar: String) async -> (Int, Int)\n",
|
||||
"func foo(bar: String) async -> (Int, Int) {}\n",
|
||||
"func foo() async throws -> (Int, Int)\n",
|
||||
"func foo() async throws -> (Int, Int) {}\n",
|
||||
"let foo: (Int, Int, Int) async -> Void\n",
|
||||
"let foo: (Int, Int, Int) async throws -> Void\n",
|
||||
"func foo(bar: (Int, String, Float) async -> Void)\n",
|
||||
"func foo(bar: (Int, String, Float) async throws -> Void)\n",
|
||||
"func getDictionaryAndInt() async -> (Dictionary<Int, String>, Int)?\n",
|
||||
"func getGenericTypeAndInt() async -> (Type<Int, String, Float>, Int)?\n"
|
||||
Example("let foo: (Int, Int)\n"),
|
||||
Example("let foo: (start: Int, end: Int)\n"),
|
||||
Example("let foo: (Int, (Int, String))\n"),
|
||||
Example("func foo() -> (Int, Int)\n"),
|
||||
Example("func foo() -> (Int, Int) {}\n"),
|
||||
Example("func foo(bar: String) -> (Int, Int)\n"),
|
||||
Example("func foo(bar: String) -> (Int, Int) {}\n"),
|
||||
Example("func foo() throws -> (Int, Int)\n"),
|
||||
Example("func foo() throws -> (Int, Int) {}\n"),
|
||||
Example("let foo: (Int, Int, Int) -> Void\n"),
|
||||
Example("let foo: (Int, Int, Int) throws -> Void\n"),
|
||||
Example("func foo(bar: (Int, String, Float) -> Void)\n"),
|
||||
Example("func foo(bar: (Int, String, Float) throws -> Void)\n"),
|
||||
Example("var completionHandler: ((_ data: Data?, _ resp: URLResponse?, _ e: NSError?) -> Void)!\n"),
|
||||
Example("func getDictionaryAndInt() -> (Dictionary<Int, String>, Int)?\n"),
|
||||
Example("func getGenericTypeAndInt() -> (Type<Int, String, Float>, Int)?\n"),
|
||||
Example("func foo() async -> (Int, Int)\n"),
|
||||
Example("func foo() async -> (Int, Int) {}\n"),
|
||||
Example("func foo(bar: String) async -> (Int, Int)\n"),
|
||||
Example("func foo(bar: String) async -> (Int, Int) {}\n"),
|
||||
Example("func foo() async throws -> (Int, Int)\n"),
|
||||
Example("func foo() async throws -> (Int, Int) {}\n"),
|
||||
Example("let foo: (Int, Int, Int) async -> Void\n"),
|
||||
Example("let foo: (Int, Int, Int) async throws -> Void\n"),
|
||||
Example("func foo(bar: (Int, String, Float) async -> Void)\n"),
|
||||
Example("func foo(bar: (Int, String, Float) async throws -> Void)\n"),
|
||||
Example("func getDictionaryAndInt() async -> (Dictionary<Int, String>, Int)?\n"),
|
||||
Example("func getGenericTypeAndInt() async -> (Type<Int, String, Float>, Int)?\n")
|
||||
]
|
||||
|
||||
static let triggeringExamples: [Example] = [
|
||||
"let foo: ↓(Int, Int, Int)\n",
|
||||
"let foo: ↓(start: Int, end: Int, value: String)\n",
|
||||
"let foo: (Int, ↓(Int, Int, Int))\n",
|
||||
"func foo(bar: ↓(Int, Int, Int))\n",
|
||||
"func foo() -> ↓(Int, Int, Int)\n",
|
||||
"func foo() -> ↓(Int, Int, Int) {}\n",
|
||||
"func foo(bar: String) -> ↓(Int, Int, Int)\n",
|
||||
"func foo(bar: String) -> ↓(Int, Int, Int) {}\n",
|
||||
"func foo() throws -> ↓(Int, Int, Int)\n",
|
||||
"func foo() throws -> ↓(Int, Int, Int) {}\n",
|
||||
"func foo() throws -> ↓(Int, ↓(String, String, String), Int) {}\n",
|
||||
"func getDictionaryAndInt() -> (Dictionary<Int, ↓(String, String, String)>, Int)?\n",
|
||||
"func foo(bar: ↓(Int, Int, Int)) async\n",
|
||||
"func foo() async -> ↓(Int, Int, Int)\n",
|
||||
"func foo() async -> ↓(Int, Int, Int) {}\n",
|
||||
"func foo(bar: String) async -> ↓(Int, Int, Int)\n",
|
||||
"func foo(bar: String) async -> ↓(Int, Int, Int) {}\n",
|
||||
"func foo() async throws -> ↓(Int, Int, Int)\n",
|
||||
"func foo() async throws -> ↓(Int, Int, Int) {}\n",
|
||||
"func foo() async throws -> ↓(Int, ↓(String, String, String), Int) {}\n",
|
||||
"func getDictionaryAndInt() async -> (Dictionary<Int, ↓(String, String, String)>, Int)?\n"
|
||||
Example("let foo: ↓(Int, Int, Int)\n"),
|
||||
Example("let foo: ↓(start: Int, end: Int, value: String)\n"),
|
||||
Example("let foo: (Int, ↓(Int, Int, Int))\n"),
|
||||
Example("func foo(bar: ↓(Int, Int, Int))\n"),
|
||||
Example("func foo() -> ↓(Int, Int, Int)\n"),
|
||||
Example("func foo() -> ↓(Int, Int, Int) {}\n"),
|
||||
Example("func foo(bar: String) -> ↓(Int, Int, Int)\n"),
|
||||
Example("func foo(bar: String) -> ↓(Int, Int, Int) {}\n"),
|
||||
Example("func foo() throws -> ↓(Int, Int, Int)\n"),
|
||||
Example("func foo() throws -> ↓(Int, Int, Int) {}\n"),
|
||||
Example("func foo() throws -> ↓(Int, ↓(String, String, String), Int) {}\n"),
|
||||
Example("func getDictionaryAndInt() -> (Dictionary<Int, ↓(String, String, String)>, Int)?\n"),
|
||||
Example("func foo(bar: ↓(Int, Int, Int)) async\n"),
|
||||
Example("func foo() async -> ↓(Int, Int, Int)\n"),
|
||||
Example("func foo() async -> ↓(Int, Int, Int) {}\n"),
|
||||
Example("func foo(bar: String) async -> ↓(Int, Int, Int)\n"),
|
||||
Example("func foo(bar: String) async -> ↓(Int, Int, Int) {}\n"),
|
||||
Example("func foo() async throws -> ↓(Int, Int, Int)\n"),
|
||||
Example("func foo() async throws -> ↓(Int, Int, Int) {}\n"),
|
||||
Example("func foo() async throws -> ↓(Int, ↓(String, String, String), Int) {}\n"),
|
||||
Example("func getDictionaryAndInt() async -> (Dictionary<Int, ↓(String, String, String)>, Int)?\n")
|
||||
]
|
||||
}
|
||||
|
||||
@@ -10,20 +10,20 @@ struct ContainsOverFilterCountRule: SwiftSyntaxRule, OptInRule, ConfigurationPro
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: [">", "==", "!="].flatMap { operation in
|
||||
return [
|
||||
"let result = myList.filter(where: { $0 % 2 == 0 }).count \(operation) 1\n",
|
||||
"let result = myList.filter { $0 % 2 == 0 }.count \(operation) 1\n",
|
||||
"let result = myList.filter(where: { $0 % 2 == 0 }).count \(operation) 01\n"
|
||||
Example("let result = myList.filter(where: { $0 % 2 == 0 }).count \(operation) 1\n"),
|
||||
Example("let result = myList.filter { $0 % 2 == 0 }.count \(operation) 1\n"),
|
||||
Example("let result = myList.filter(where: { $0 % 2 == 0 }).count \(operation) 01\n")
|
||||
]
|
||||
} + [
|
||||
"let result = myList.contains(where: { $0 % 2 == 0 })\n",
|
||||
"let result = !myList.contains(where: { $0 % 2 == 0 })\n",
|
||||
"let result = myList.contains(10)\n"
|
||||
Example("let result = myList.contains(where: { $0 % 2 == 0 })\n"),
|
||||
Example("let result = !myList.contains(where: { $0 % 2 == 0 })\n"),
|
||||
Example("let result = myList.contains(10)\n")
|
||||
],
|
||||
triggeringExamples: [">", "==", "!="].flatMap { operation in
|
||||
return [
|
||||
"let result = ↓myList.filter(where: { $0 % 2 == 0 }).count \(operation) 0\n",
|
||||
"let result = ↓myList.filter { $0 % 2 == 0 }.count \(operation) 0\n",
|
||||
"let result = ↓myList.filter(where: someFunction).count \(operation) 0\n"
|
||||
Example("let result = ↓myList.filter(where: { $0 % 2 == 0 }).count \(operation) 0\n"),
|
||||
Example("let result = ↓myList.filter { $0 % 2 == 0 }.count \(operation) 0\n"),
|
||||
Example("let result = ↓myList.filter(where: someFunction).count \(operation) 0\n")
|
||||
]
|
||||
}
|
||||
)
|
||||
|
||||
@@ -10,19 +10,19 @@ struct ContainsOverFilterIsEmptyRule: SwiftSyntaxRule, OptInRule, ConfigurationP
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: [">", "==", "!="].flatMap { operation in
|
||||
return [
|
||||
"let result = myList.filter(where: { $0 % 2 == 0 }).count \(operation) 1\n",
|
||||
"let result = myList.filter { $0 % 2 == 0 }.count \(operation) 1\n"
|
||||
Example("let result = myList.filter(where: { $0 % 2 == 0 }).count \(operation) 1\n"),
|
||||
Example("let result = myList.filter { $0 % 2 == 0 }.count \(operation) 1\n")
|
||||
]
|
||||
} + [
|
||||
"let result = myList.contains(where: { $0 % 2 == 0 })\n",
|
||||
"let result = !myList.contains(where: { $0 % 2 == 0 })\n",
|
||||
"let result = myList.contains(10)\n"
|
||||
Example("let result = myList.contains(where: { $0 % 2 == 0 })\n"),
|
||||
Example("let result = !myList.contains(where: { $0 % 2 == 0 })\n"),
|
||||
Example("let result = myList.contains(10)\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"let result = ↓myList.filter(where: { $0 % 2 == 0 }).isEmpty\n",
|
||||
"let result = !↓myList.filter(where: { $0 % 2 == 0 }).isEmpty\n",
|
||||
"let result = ↓myList.filter { $0 % 2 == 0 }.isEmpty\n",
|
||||
"let result = ↓myList.filter(where: someFunction).isEmpty\n"
|
||||
Example("let result = ↓myList.filter(where: { $0 % 2 == 0 }).isEmpty\n"),
|
||||
Example("let result = !↓myList.filter(where: { $0 % 2 == 0 }).isEmpty\n"),
|
||||
Example("let result = ↓myList.filter { $0 % 2 == 0 }.isEmpty\n"),
|
||||
Example("let result = ↓myList.filter(where: someFunction).isEmpty\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -10,19 +10,19 @@ struct ContainsOverFirstNotNilRule: SwiftSyntaxRule, OptInRule, ConfigurationPro
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: ["first", "firstIndex"].flatMap { method in
|
||||
return [
|
||||
"let \(method) = myList.\(method)(where: { $0 % 2 == 0 })\n",
|
||||
"let \(method) = myList.\(method) { $0 % 2 == 0 }\n"
|
||||
Example("let \(method) = myList.\(method)(where: { $0 % 2 == 0 })\n"),
|
||||
Example("let \(method) = myList.\(method) { $0 % 2 == 0 }\n")
|
||||
]
|
||||
},
|
||||
triggeringExamples: ["first", "firstIndex"].flatMap { method in
|
||||
return ["!=", "=="].flatMap { comparison in
|
||||
return [
|
||||
"↓myList.\(method) { $0 % 2 == 0 } \(comparison) nil\n",
|
||||
"↓myList.\(method)(where: { $0 % 2 == 0 }) \(comparison) nil\n",
|
||||
"↓myList.map { $0 + 1 }.\(method)(where: { $0 % 2 == 0 }) \(comparison) nil\n",
|
||||
"↓myList.\(method)(where: someFunction) \(comparison) nil\n",
|
||||
"↓myList.map { $0 + 1 }.\(method) { $0 % 2 == 0 } \(comparison) nil\n",
|
||||
"(↓myList.\(method) { $0 % 2 == 0 }) \(comparison) nil\n"
|
||||
Example("↓myList.\(method) { $0 % 2 == 0 } \(comparison) nil\n"),
|
||||
Example("↓myList.\(method)(where: { $0 % 2 == 0 }) \(comparison) nil\n"),
|
||||
Example("↓myList.map { $0 + 1 }.\(method)(where: { $0 % 2 == 0 }) \(comparison) nil\n"),
|
||||
Example("↓myList.\(method)(where: someFunction) \(comparison) nil\n"),
|
||||
Example("↓myList.map { $0 + 1 }.\(method) { $0 % 2 == 0 } \(comparison) nil\n"),
|
||||
Example("(↓myList.\(method) { $0 % 2 == 0 }) \(comparison) nil\n")
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
+9
-8
@@ -9,15 +9,16 @@ struct ContainsOverRangeNilComparisonRule: SwiftSyntaxRule, OptInRule, Configura
|
||||
description: "Prefer `contains` over `range(of:) != nil` and `range(of:) == nil`",
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: [
|
||||
"let range = myString.range(of: \"Test\")",
|
||||
"myString.contains(\"Test\")",
|
||||
"!myString.contains(\"Test\")",
|
||||
"resourceString.range(of: rule.regex, options: .regularExpression) != nil"
|
||||
Example("let range = myString.range(of: \"Test\")"),
|
||||
Example("myString.contains(\"Test\")"),
|
||||
Example("!myString.contains(\"Test\")"),
|
||||
Example("resourceString.range(of: rule.regex, options: .regularExpression) != nil")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓myString.range(of: \"Test\") != nil",
|
||||
"↓myString.range(of: \"Test\") == nil"
|
||||
]
|
||||
triggeringExamples: ["!=", "=="].flatMap { comparison in
|
||||
return [
|
||||
Example("↓myString.range(of: \"Test\") \(comparison) nil")
|
||||
]
|
||||
}
|
||||
)
|
||||
|
||||
func preprocess(file: SwiftLintFile) -> SourceFileSyntax? {
|
||||
|
||||
@@ -9,20 +9,20 @@ struct EmptyCollectionLiteralRule: SwiftSyntaxRule, ConfigurationProviderRule, O
|
||||
description: "Prefer checking `isEmpty` over comparing collection to an empty array or dictionary literal",
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: [
|
||||
"myArray = []",
|
||||
"myArray.isEmpty",
|
||||
"!myArray.isEmpty",
|
||||
"myDict = [:]"
|
||||
Example("myArray = []"),
|
||||
Example("myArray.isEmpty"),
|
||||
Example("!myArray.isEmpty"),
|
||||
Example("myDict = [:]")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"myArray↓ == []",
|
||||
"myArray↓ != []",
|
||||
"myArray↓ == [ ]",
|
||||
"myDict↓ == [:]",
|
||||
"myDict↓ != [:]",
|
||||
"myDict↓ == [: ]",
|
||||
"myDict↓ == [ :]",
|
||||
"myDict↓ == [ : ]"
|
||||
Example("myArray↓ == []"),
|
||||
Example("myArray↓ != []"),
|
||||
Example("myArray↓ == [ ]"),
|
||||
Example("myDict↓ == [:]"),
|
||||
Example("myDict↓ != [:]"),
|
||||
Example("myDict↓ == [: ]"),
|
||||
Example("myDict↓ == [ :]"),
|
||||
Example("myDict↓ == [ : ]")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,27 +9,27 @@ struct EmptyCountRule: ConfigurationProviderRule, OptInRule, SwiftSyntaxRule {
|
||||
description: "Prefer checking `isEmpty` over comparing `count` to zero",
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: [
|
||||
"var count = 0\n",
|
||||
"[Int]().isEmpty\n",
|
||||
"[Int]().count > 1\n",
|
||||
"[Int]().count == 1\n",
|
||||
"[Int]().count == 0xff\n",
|
||||
"[Int]().count == 0b01\n",
|
||||
"[Int]().count == 0o07\n",
|
||||
"discount == 0\n",
|
||||
"order.discount == 0\n"
|
||||
Example("var count = 0\n"),
|
||||
Example("[Int]().isEmpty\n"),
|
||||
Example("[Int]().count > 1\n"),
|
||||
Example("[Int]().count == 1\n"),
|
||||
Example("[Int]().count == 0xff\n"),
|
||||
Example("[Int]().count == 0b01\n"),
|
||||
Example("[Int]().count == 0o07\n"),
|
||||
Example("discount == 0\n"),
|
||||
Example("order.discount == 0\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"[Int]().↓count == 0\n",
|
||||
"0 == [Int]().↓count\n",
|
||||
"[Int]().↓count==0\n",
|
||||
"[Int]().↓count > 0\n",
|
||||
"[Int]().↓count != 0\n",
|
||||
"[Int]().↓count == 0x0\n",
|
||||
"[Int]().↓count == 0x00_00\n",
|
||||
"[Int]().↓count == 0b00\n",
|
||||
"[Int]().↓count == 0o00\n",
|
||||
"↓count == 0\n"
|
||||
Example("[Int]().↓count == 0\n"),
|
||||
Example("0 == [Int]().↓count\n"),
|
||||
Example("[Int]().↓count==0\n"),
|
||||
Example("[Int]().↓count > 0\n"),
|
||||
Example("[Int]().↓count != 0\n"),
|
||||
Example("[Int]().↓count == 0x0\n"),
|
||||
Example("[Int]().↓count == 0x00_00\n"),
|
||||
Example("[Int]().↓count == 0b00\n"),
|
||||
Example("[Int]().↓count == 0o00\n"),
|
||||
Example("↓count == 0\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,11 +9,11 @@ struct FlatMapOverMapReduceRule: SwiftSyntaxRule, OptInRule, ConfigurationProvid
|
||||
description: "Prefer `flatMap` over `map` followed by `reduce([], +)`",
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: [
|
||||
"let foo = bar.map { $0.count }.reduce(0, +)",
|
||||
"let foo = bar.flatMap { $0.array }"
|
||||
Example("let foo = bar.map { $0.count }.reduce(0, +)"),
|
||||
Example("let foo = bar.flatMap { $0.array }")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"let foo = ↓bar.map { $0.array }.reduce([], +)"
|
||||
Example("let foo = ↓bar.map { $0.array }.reduce([], +)")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,20 +9,20 @@ struct ReduceBooleanRule: SwiftSyntaxRule, ConfigurationProviderRule {
|
||||
description: "Prefer using `.allSatisfy()` or `.contains()` over `reduce(true)` or `reduce(false)`.",
|
||||
kind: .performance,
|
||||
nonTriggeringExamples: [
|
||||
"nums.reduce(0) { $0.0 + $0.1 }",
|
||||
"nums.reduce(0.0) { $0.0 + $0.1 }",
|
||||
"nums.reduce(initial: true) { $0.0 && $0.1 == 3 }"
|
||||
Example("nums.reduce(0) { $0.0 + $0.1 }"),
|
||||
Example("nums.reduce(0.0) { $0.0 + $0.1 }"),
|
||||
Example("nums.reduce(initial: true) { $0.0 && $0.1 == 3 }")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"let allNines = nums.↓reduce(true) { $0.0 && $0.1 == 9 }",
|
||||
"let anyNines = nums.↓reduce(false) { $0.0 || $0.1 == 9 }",
|
||||
"let allValid = validators.↓reduce(true) { $0 && $1(input) }",
|
||||
"let anyValid = validators.↓reduce(false) { $0 || $1(input) }",
|
||||
"let allNines = nums.↓reduce(true, { $0.0 && $0.1 == 9 })",
|
||||
"let anyNines = nums.↓reduce(false, { $0.0 || $0.1 == 9 })",
|
||||
"let allValid = validators.↓reduce(true, { $0 && $1(input) })",
|
||||
"let anyValid = validators.↓reduce(false, { $0 || $1(input) })",
|
||||
"nums.reduce(into: true) { (r: inout Bool, s) in r = r && (s == 3) }"
|
||||
Example("let allNines = nums.↓reduce(true) { $0.0 && $0.1 == 9 }"),
|
||||
Example("let anyNines = nums.↓reduce(false) { $0.0 || $0.1 == 9 }"),
|
||||
Example("let allValid = validators.↓reduce(true) { $0 && $1(input) }"),
|
||||
Example("let anyValid = validators.↓reduce(false) { $0 || $1(input) }"),
|
||||
Example("let allNines = nums.↓reduce(true, { $0.0 && $0.1 == 9 })"),
|
||||
Example("let anyNines = nums.↓reduce(false, { $0.0 || $0.1 == 9 })"),
|
||||
Example("let allValid = validators.↓reduce(true, { $0 && $1(input) })"),
|
||||
Example("let anyValid = validators.↓reduce(false, { $0 || $1(input) })"),
|
||||
Example("nums.reduce(into: true) { (r: inout Bool, s) in r = r && (s == 3) }")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -9,17 +9,17 @@ struct OperatorFunctionWhitespaceRule: ConfigurationProviderRule, SwiftSyntaxRul
|
||||
description: "Operators should be surrounded by a single whitespace when defining them",
|
||||
kind: .style,
|
||||
nonTriggeringExamples: [
|
||||
"func <| (lhs: Int, rhs: Int) -> Int {}\n",
|
||||
"func <|< <A>(lhs: A, rhs: A) -> A {}\n",
|
||||
"func abc(lhs: Int, rhs: Int) -> Int {}\n"
|
||||
Example("func <| (lhs: Int, rhs: Int) -> Int {}\n"),
|
||||
Example("func <|< <A>(lhs: A, rhs: A) -> A {}\n"),
|
||||
Example("func abc(lhs: Int, rhs: Int) -> Int {}\n")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓func <|(lhs: Int, rhs: Int) -> Int {}\n", // no spaces after
|
||||
"↓func <|<<A>(lhs: A, rhs: A) -> A {}\n", // no spaces after
|
||||
"↓func <| (lhs: Int, rhs: Int) -> Int {}\n", // 2 spaces after
|
||||
"↓func <|< <A>(lhs: A, rhs: A) -> A {}\n", // 2 spaces after
|
||||
"↓func <| (lhs: Int, rhs: Int) -> Int {}\n", // 2 spaces before
|
||||
"↓func <|< <A>(lhs: A, rhs: A) -> A {}\n" // 2 spaces before
|
||||
Example("↓func <|(lhs: Int, rhs: Int) -> Int {}\n"), // no spaces after
|
||||
Example("↓func <|<<A>(lhs: A, rhs: A) -> A {}\n"), // no spaces after
|
||||
Example("↓func <| (lhs: Int, rhs: Int) -> Int {}\n"), // 2 spaces after
|
||||
Example("↓func <|< <A>(lhs: A, rhs: A) -> A {}\n"), // 2 spaces after
|
||||
Example("↓func <| (lhs: Int, rhs: Int) -> Int {}\n"), // 2 spaces before
|
||||
Example("↓func <|< <A>(lhs: A, rhs: A) -> A {}\n") // 2 spaces before
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -10,21 +10,21 @@ struct TrailingClosureRule: OptInRule, ConfigurationProviderRule {
|
||||
description: "Trailing closure syntax should be used whenever possible",
|
||||
kind: .style,
|
||||
nonTriggeringExamples: [
|
||||
"foo.map { $0 + 1 }\n",
|
||||
"foo.bar()\n",
|
||||
"foo.reduce(0) { $0 + 1 }\n",
|
||||
"if let foo = bar.map({ $0 + 1 }) { }\n",
|
||||
"foo.something(param1: { $0 }, param2: { $0 + 1 })\n",
|
||||
"offsets.sorted { $0.offset < $1.offset }\n",
|
||||
"foo.something({ return 1 }())",
|
||||
"foo.something({ return $0 }(1))",
|
||||
"foo.something(0, { return 1 }())"
|
||||
Example("foo.map { $0 + 1 }\n"),
|
||||
Example("foo.bar()\n"),
|
||||
Example("foo.reduce(0) { $0 + 1 }\n"),
|
||||
Example("if let foo = bar.map({ $0 + 1 }) { }\n"),
|
||||
Example("foo.something(param1: { $0 }, param2: { $0 + 1 })\n"),
|
||||
Example("offsets.sorted { $0.offset < $1.offset }\n"),
|
||||
Example("foo.something({ return 1 }())"),
|
||||
Example("foo.something({ return $0 }(1))"),
|
||||
Example("foo.something(0, { return 1 }())")
|
||||
],
|
||||
triggeringExamples: [
|
||||
"↓foo.map({ $0 + 1 })\n",
|
||||
"↓foo.reduce(0, combine: { $0 + 1 })\n",
|
||||
"↓offsets.sorted(by: { $0.offset < $1.offset })\n",
|
||||
"↓foo.something(0, { $0 + 1 })\n"
|
||||
Example("↓foo.map({ $0 + 1 })\n"),
|
||||
Example("↓foo.reduce(0, combine: { $0 + 1 })\n"),
|
||||
Example("↓offsets.sorted(by: { $0.offset < $1.offset })\n"),
|
||||
Example("↓foo.something(0, { $0 + 1 })\n")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
@@ -147,13 +147,6 @@ extension Example: Comparable {
|
||||
}
|
||||
}
|
||||
|
||||
/// Allows to initialize an ``Example`` as `let example: Example = "..."`.
|
||||
extension Example: ExpressibleByStringInterpolation {
|
||||
public init(stringLiteral value: String) {
|
||||
self.init(value)
|
||||
}
|
||||
}
|
||||
|
||||
public extension Array where Element == Example {
|
||||
/// Make these examples skip wrapping in comment tests.
|
||||
func skipWrappingInCommentTests() -> Self {
|
||||
|
||||
Reference in New Issue
Block a user