     return "class Foo {\n  \(value)\n}\n"
 }
 
-public struct ImplicitGetterRule: ASTRule, ConfigurationProviderRule {
+public struct ImplicitGetterRule: Rule, ConfigurationProviderRule {
     public var configuration = SeverityConfiguration(.Warning)
 
     public init() {}

        ]
    )

    public func validateFile(file: File,
                             kind: SwiftDeclarationKind,
                             dictionary: [String: SourceKitRepresentable]) -> [StyleViolation] {
        let typeKinds: [SwiftDeclarationKind] = [
            .Class,
            .Enum,
            .Extension,
            .ExtensionClass,
            .ExtensionEnum,
            .ExtensionProtocol,
            .ExtensionStruct,
            .Struct
        ]

        guard typeKinds.contains(kind) else {
            return []
        }

        guard let substructures = (dictionary["key.substructure"] as? [SourceKitRepresentable])?
            .flatMap({ $0 as? [String: SourceKitRepresentable] }) else {
                return []
        }

        return substructures.flatMap { dictionary -> [StyleViolation] in
            guard let kind = (dictionary["key.kind"] as? String).flatMap(KindType.init) else {
                return []
            }

            return validateType(file, kind: kind, dictionary: dictionary)
        }
    }

    private func validateType(file: File,
                              kind: SwiftDeclarationKind,
                              dictionary: [String: SourceKitRepresentable]) -> [StyleViolation] {
        let allowedKinds: [SwiftDeclarationKind] = [.VarClass, .VarInstance, .VarStatic]
        guard allowedKinds.contains(kind) else {
            return []
        }

        // If there's a setter, `get` is allowed
        guard dictionary["key.setter_accessibility"] == nil else {
            return []
        }

        // Only validates properties with body
        guard let bodyOffset = (dictionary["key.bodyoffset"] as? Int64).flatMap({ Int($0) }),
            bodyLength = (dictionary["key.bodylength"] as? Int64).flatMap({ Int($0) }) else {
                return []
        }

        let bodyRange = NSRange(location: bodyOffset, length: bodyLength)
        let contents = (file.contents as NSString)

        let tokens = file.syntaxMap.tokensIn(bodyRange).filter { token in
            guard SyntaxKind(rawValue: token.type) == .Keyword else {
                return false
            }

            guard let tokenValue = contents.substringWithByteRange(start: token.offset,
                                                                   length: token.length) else {
                return false
            }

            return tokenValue == "get"
        }

        return tokens.map { token in
            // Violation found!
            let location = Location(file: file, byteOffset: token.offset)


            )
        }
    }

    private func variableDeclarationsFor(byteOffset: Int, structure: Structure) ->
                                                             [[String : SourceKitRepresentable]] {
        var results = [[String : SourceKitRepresentable]]()

        func parse(dictionary: [String : SourceKitRepresentable]) {

            let allowedKinds: [SwiftDeclarationKind] = [.VarClass, .VarInstance, .VarStatic]

            // Only accepts variable declarations which contains a body and contains the
            // searched byteOffset
            if let kindString = (dictionary["key.kind"] as? String),
                kind = SwiftDeclarationKind(rawValue: kindString),
                bodyOffset = (dictionary["key.bodyoffset"] as? Int64).flatMap({ Int($0) }),
                bodyLength = (dictionary["key.bodylength"] as? Int64).flatMap({ Int($0) })
                where allowedKinds.contains(kind) {
                let byteRange = NSRange(location: bodyOffset, length: bodyLength)

                if NSLocationInRange(byteOffset, byteRange) {
                    results.append(dictionary)
                }
            }

            let typeKinds: [SwiftDeclarationKind] = [
                .Class,
                .Enum,
                .Extension,
                .ExtensionClass,
                .ExtensionEnum,
                .ExtensionProtocol,
                .ExtensionStruct,
                .Struct
                ] + allowedKinds

            if let subStructure = dictionary["key.substructure"] as? [SourceKitRepresentable] {
                for case let dictionary as [String : SourceKitRepresentable] in subStructure {
                    if let kindString = (dictionary["key.kind"] as? String),
                        kind = SwiftDeclarationKind(rawValue: kindString)
                        where typeKinds.contains(kind) {
                        parse(dictionary)
                    }
                }
            }
        }
        parse(structure.dictionary)
        return results
    }
}
