     case beforeSuite
     case afterEach
     case afterSuite
-    case it
+    case it // swiftlint:disable:this identifier_name
     case pending
 
-    static let restrictiveKinds: [QuickCallKind] = [.describe, .context, .sharedExamples]
+    static let restrictiveKinds: Set<QuickCallKind> = [.describe, .context, .sharedExamples]
 }
-// swiftlint:enabled identifier_name

            QuickCallKind.restrictiveKinds.contains(kindName)
            else { return [] }

        // and is this call within the bounds of a QuickSpec calls?
        guard
            let callBounds = structureBounds(dictionary: dictionary),
            !quickSpec(file: file)
                .flatMap(structureBounds)
                .filter(contains(offset: callBounds.offset))
                .isEmpty
            else { return [] }

        return violationOffsets(in: dictionary.enclosedArguments)
            .map {
                StyleViolation(ruleDescription: type(of: self).description,
                               severity: configuration.severity,
                               location: Location(file: file, byteOffset: $0),
                               reason: "Discouraged call inside a '\(name)' block.")
            }
    }

    // MARK: - Private

    typealias StructureBounds = (offset: Int, length: Int)
    typealias ViolationOffset = Int

    private func quickSpec(file: File) -> [[String: SourceKitRepresentable]] {
        return file.structure.dictionary.substructure.filter { $0.inheritedTypes.contains("QuickSpec") }
    }

    private func structureBounds(dictionary: [String: SourceKitRepresentable]) -> StructureBounds? {
        guard
            let offset = dictionary.offset,
            let length = dictionary.length
            else { return nil }

        return StructureBounds(offset: offset, length: length)
    }

    private func contains(offset: Int) -> (StructureBounds) -> Bool {
        return { structureBounds in
            structureBounds.offset..<(structureBounds.offset + structureBounds.length) ~= offset
        }
    }

    private func violationOffsets(in substructure: [[String: SourceKitRepresentable]]) -> [ViolationOffset] {
        return substructure.flatMap { dictionary -> [ViolationOffset] in
            return dictionary.substructure.flatMap(toViolationOffsets)
        }
    }

    private func toViolationOffsets(dictionary: [String: SourceKitRepresentable]) -> [ViolationOffset] {
        guard
            let kind = dictionary.kind,
            let offset = dictionary.offset

        return dictionary.substructure.flatMap(toViolationOffset)
    }

    private func toViolationOffset(dictionary: [String: SourceKitRepresentable]) -> Int? {
        guard
            let name = dictionary.name,
            let offset = dictionary.offset,
