                     genericTypesForFunction(file, kind: kind, dictionary: dictionary)
 
         return types.flatMap { validateName(name: $0.0, file: file, offset: $0.1) }
+    }
+
+    private func validateGenericTypeAliases(_ file: File) -> [StyleViolation] {
+        let pattern = "typealias\\s+.+?" + genericTypePattern + "\\s*="
+        return file.matchPattern(pattern).flatMap { (range, tokens) -> [(String, Int)] in
+            guard tokens.count > 1, tokens.first == .keyword,
+                Set(tokens.dropFirst()) == [.identifier],
+                let match = genericTypeRegex.firstMatch(in: file.contents, options: [],
+                                                        range: range)?.rangeAt(1) else {
+                    return []
+            }
+
+            let genericConstraint = file.contents.bridge().substring(with: match)
+            return extractTypesFromGenericConstraint(genericConstraint, offset: match.location, file: file)
+        }.flatMap { validateName(name: $0.0, file: file, offset: $0.1) }
     }
 
     private func genericTypesForType(_ file: File,

            let length = (dictionary["key.namelength"] as? Int64).flatMap({ Int($0) }),
            case let contents = file.contents.bridge(),
            let range = contents.byteRangeToNSRange(start: offset, length: length),
            let match = pattern.firstMatch(in: file.contents, options: [], range: range)?.rangeAt(1),
            match.location < minParameterOffset(parameters: dictionary.enclosedVarParameters, file: file) else {
            return []
        }

        }
    )

    private let genericTypePattern = "<(\\s*\\w.*?)>"
    private var genericTypeRegex: NSRegularExpression {
        return regex(genericTypePattern)
    }

    public func validateFile(_ file: File) -> [StyleViolation] {
        return validateFile(file, dictionary: file.structure.dictionary) +
            validateGenericTypeAliases(file)
    }

    public func validateFile(_ file: File,
                             kind: SwiftDeclarationKind,
