Improvements to localizability checks for iOS / OS X

[kulpreet]

Summary

• Adjusted copy to be consistent with diagnostic text in other Apple API checkers
• Added in ~150 UIKit / AppKit methods that require localized strings in UnlocalizedStringsChecker
• UnlocalizedStringChecker now checks for UI methods up the class hierarchy and UI methods that conform for a certain Objective-C protocol.
• Added in alpha version of PluralMisuseChecker and some regression tests. False positives are still not ideal.

[xazax.hun]

I think in general, it might be better to have all the UI methods in a separate file, in a specific format, and you could include that file and use a macro, to generate the code.

[zaks.anna]

Thanks for working on this!

Added in ~150 UIKit / AppKit methods that require localized strings in UnlocalizedStringsChecker

It might be more efficient to store identifiers. Have you considered that approach?

For the Plural Misuse Checker Tests, please, add some test cases that show the common false positives that your checker already avoids as well as common false positives it does not deal with right now. (And mark them clearly to tell the difference.) These are important to ensure that we do not regress in false positive rates once someone less familiar with the checker modifies it!

Other comments are inline.

lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

1114

For better readability, please, rename into something like isCheckingPlurality.

1138

Is there a "working" test case for this?

1145

Should this I/O line be removed?

1174

FD->getNameInfo().getAsString() is a temporary variable, so it might get deallocated by the time you use NormalizeName. Please, build and test with ASan on.

You could also check the return type of the Decl.

1213

You could simplify this code with an early return statement.

Why do we need to override traverse?
"/ users may override Traverse* and WalkUpFrom* to implement custom
/ traversal strategies. Returning false from one of these overridden
/// functions will abort the entire traversal."

If you are trying to avoid traversing everything that's not an IfStmt, maybe you could call Visitor.TraverseStmt on the top level if statements..

1270

"Use a .stringsdict file" -> "Use a .stringsdict file instead"

[kulpreet]

It might be more efficient to store identifiers. Have you considered that approach?

I did consider this approach a while back, but I ran into a problem when I realized that Selector comparison doesn’t work the way I expected it. You can see it in this debug output:

   765 	
   766 	  Selector S = msg.getSelector();
   767 	
-> 768 	  std::string SelectorString = S.getAsString();
   769 	  StringRef SelectorName = SelectorString;
   770 	  assert(!SelectorName.empty());
   771 	
(lldb) p S
(clang::Selector) $3 = (InfoPtr = 4513118723)
(lldb) p S.getAsString()
(std::__1::string) $4 = "localizedStringForKey:value:table:"
(lldb) p getKeywordSelector(C.getASTContext(),"localizedStringForKey:","value:","table:",nullptr)
(clang::Selector) $5 = (InfoPtr = 4513118835)
(lldb) p S == getKeywordSelector(C.getASTContext(),"localizedStringForKey:","value:","table:",nullptr)
(bool) $7 = false

Looking at the implementation of getKeywordSelector(), it looks like a new Selector object is being constructed from the identifiers that make up the components of the selector. In its constructor, Selector maintains InfoPtr to an underlying MultiKeywordSelector object. When comparing two Selectors, this underlying InfoPtr is compared. Unfortunately, MultiKeywordSelector does not override operator==(), so it just compares the pointers directly. My guess is that it probably should compare the IdentifierInfo pointer in each slot to see if they are the same.

For the Plural Misuse Checker Tests, please, add some test cases that show the common false positives that your checker already avoids as well as common false positives it does not deal with right now.

I added a couple test cases for the one heuristic I added to reduce false positives and one for the common false positive I saw in some projects. I've been looking around for good localized projects to test this on, but there aren't many. I tested on Wikipedia iOS and there were no diagnostics raised for PluralMisuseChecker. (but there were 11 real diagnostics raised with the NonLocalizedStringChecker - hooray!)

I think in general, it might be better to have all the UI methods in a separate file, in a specific format, and you could include that file and use a macro, to generate the code.

This is something I will look into in the future, since I've already generated this code.

lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

1138

This is tested in test5: in localization.m

1174

I tested with ASan on and there were no memory issues reported. I think here NormalizeName doesn't get deallocated because it's the result of StringRef.lower().

1213

I simplified the code as per your recommendation.

We override TraverseIfStmt to keep track of whether we are inside (visiting the children) of an IfStmt. By overriding TraverseIfStmt, we know when we have finished visiting all of the children of a matching IfStmt and can set InMatchingStatment to false.

I discussed this problem with Gabor a while back and that was the solution we came up with.

[kulpreet]

Incorporated feedback from Anna.

[xazax.hun]

lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

1209

In the visitor pattern BeginVisit and EndVisit are commonly used terms. Maybe it would be cleaner to refactor the code bellow into a separate method that has a name like EndVisitIfStmt and add a comment here that EndVisit callbacks are not provided by the recursiveASTVisitor, and this is the code to add it.

[xazax.hun]

In D12417#237689, @kulpreet wrote:

Looking at the implementation of getKeywordSelector(), it looks like a new Selector object is being constructed from the identifiers that make up the components of the selector. In its constructor, Selector maintains InfoPtr to an underlying MultiKeywordSelector object. When comparing two Selectors, this underlying InfoPtr is compared. Unfortunately, MultiKeywordSelector does not override operator==(), so it just compares the pointers directly. My guess is that it probably should compare the IdentifierInfo pointer in each slot to see if they are the same.

I think, if that is the only reason why storing identifiers/selectors does not work, it could be a good enough motivation to implement proper == operators in clang!

In general, == should be either disabled or work intuitively.

[kulpreet]

NonLocalizedStringChecker:

• Got the Selector/Identifier object comparison working! So no more string comparison for UIMethods
• Moved over to using macros for list of UIMethods as per Gabor's recommendation

PluralMisuseChecker:

• Separated out TraverseIfStmt function into EndVisitIfStmt in to make it clear that this is after an IfStmt is visited

(Sorry for the delay!)

[zaks.anna]

lib/StaticAnalyzer/Checkers/Checkers.td

493

It would be good to shorten the description.

[kulpreet]

Shortened description of PluralMisuseChecker in Checkers.td as per Anna's recommendation.

[dcoughlin]

This is causing tests to fail on the bots: http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/31373

/home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.obj/Release+Asserts/bin/clang -cc1 -internal-isystem /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.obj/Release+Asserts/bin/../lib/clang/3.8.0/include -nostdsysteminc -analyze -fblocks -analyzer-store=region -analyzer-checker=alpha.osx.cocoa.NonLocalizedStringChecker -analyzer-checker=alpha.osx.cocoa.PluralMisuseChecker -verify  /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m Line 115: Plural cases are not supported accross all languages. Use a .stringsdict file
  File /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m Line 117: Plural cases are not supported accross all languages. Use a .stringsdict file
  File /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m Line 124: Plural cases are not supported accross all languages. Use a .stringsdict file
  File /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m Line 126: Plural cases are not supported accross all languages. Use a .stringsdict file
  File /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m Line 134: Plural cases are not supported accross all languages. Use a .stringsdict file
  File /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m Line 136: Plural cases are not supported accross all languages. Use a .stringsdict file
  File /home/llvmbb/llvm-build-dir/clang-x86_64-debian-fast/llvm.src/tools/clang/test/Analysis/localization.m Line 150: Plural cases are not supported accross all languages. Use a .stringsdict file
7 errors generated.

lib/StaticAnalyzer/Checkers/Checkers.td

   HelpText<"Check that NSLocalizedString macros include a comment for context">,
   DescFile<"LocalizationChecker.cpp">;
 
+def PluralMisuseChecker : Checker<"PluralMisuseChecker">,
+  HelpText<"Warns against using one vs. many plural pattern in code when generating localized strings, as this doesn't work for many non-English languages.">,
+  DescFile<"LocalizationChecker.cpp">;
+
 } // end "alpha.osx.cocoa"
 
 let ParentPackage = CoreFoundation in {

lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

   void reportLocalizationError(SVal S, const ObjCMethodCall &M,
                                CheckerContext &C, int argumentNumber = 0) const;
 
+  int getLocalizedArgumentForSelector(StringRef Receiver,
+                                      StringRef SelectorName) const;
+
 public:
   NonLocalizedStringChecker();
 

                                LocalizedState)
 
 NonLocalizedStringChecker::NonLocalizedStringChecker() {
-  BT.reset(new BugType(this, "Unlocalized string", "Localizability Error"));
+  BT.reset(new BugType(this, "Unlocalizable string",
+                       "Localizability Issue (Apple)"));
 }
 
 /// Initializes a list of methods that require a localized string

   if (!UIMethods.empty())
     return;
 
-  // TODO: This should eventually be a comprehensive list of UIKit methods
+  // UISearchDisplayController Methods
+  llvm::StringMap<uint8_t> &UISearchDisplayControllerM =
+      UIMethods.insert(
+                   {"UISearchDisplayController", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UISearchDisplayControllerM.insert({"setSearchResultsTitle:", 0});
 
-  // UILabel Methods
-  llvm::StringMap<uint8_t> &UILabelM =
-      UIMethods.insert({"UILabel", llvm::StringMap<uint8_t>()}).first->second;
-  UILabelM.insert({"setText:", 0});
+  // UITabBarItem Methods
+  llvm::StringMap<uint8_t> &UITabBarItemM =
+      UIMethods.insert({"UITabBarItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UITabBarItemM.insert({"initWithTitle:image:tag:", 0});
+  UITabBarItemM.insert({"initWithTitle:image:selectedImage:", 0});
 
-  // UIButton Methods
-  llvm::StringMap<uint8_t> &UIButtonM =
-      UIMethods.insert({"UIButton", llvm::StringMap<uint8_t>()}).first->second;
-  UIButtonM.insert({"setText:", 0});
+  // NSDockTile Methods
+  llvm::StringMap<uint8_t> &NSDockTileM =
+      UIMethods.insert({"NSDockTile", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSDockTileM.insert({"setBadgeLabel:", 0});
+
+  // NSStatusItem Methods
+  llvm::StringMap<uint8_t> &NSStatusItemM =
+      UIMethods.insert({"NSStatusItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSStatusItemM.insert({"setTitle:", 0});
+  NSStatusItemM.insert({"setToolTip:", 0});
+
+  // UITableViewRowAction Methods
+  llvm::StringMap<uint8_t> &UITableViewRowActionM =
+      UIMethods.insert({"UITableViewRowAction", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UITableViewRowActionM.insert({"rowActionWithStyle:title:handler:", 1});
+  UITableViewRowActionM.insert({"setTitle:", 0});
+
+  // NSBox Methods
+  llvm::StringMap<uint8_t> &NSBoxM =
+      UIMethods.insert({"NSBox", llvm::StringMap<uint8_t>()}).first->second;
+  NSBoxM.insert({"setTitle:", 0});
+
+  // NSButton Methods
+  llvm::StringMap<uint8_t> &NSButtonM =
+      UIMethods.insert({"NSButton", llvm::StringMap<uint8_t>()}).first->second;
+  NSButtonM.insert({"setTitle:", 0});
+  NSButtonM.insert({"setAlternateTitle:", 0});
+
+  // NSSavePanel Methods
+  llvm::StringMap<uint8_t> &NSSavePanelM =
+      UIMethods.insert({"NSSavePanel", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSSavePanelM.insert({"setPrompt:", 0});
+  NSSavePanelM.insert({"setTitle:", 0});
+  NSSavePanelM.insert({"setNameFieldLabel:", 0});
+  NSSavePanelM.insert({"setNameFieldStringValue:", 0});
+  NSSavePanelM.insert({"setMessage:", 0});
+
+  // UIPrintInfo Methods
+  llvm::StringMap<uint8_t> &UIPrintInfoM =
+      UIMethods.insert({"UIPrintInfo", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIPrintInfoM.insert({"setJobName:", 0});
+
+  // NSTabViewItem Methods
+  llvm::StringMap<uint8_t> &NSTabViewItemM =
+      UIMethods.insert({"NSTabViewItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSTabViewItemM.insert({"setLabel:", 0});
+  NSTabViewItemM.insert({"setToolTip:", 0});
+
+  // NSBrowser Methods
+  llvm::StringMap<uint8_t> &NSBrowserM =
+      UIMethods.insert({"NSBrowser", llvm::StringMap<uint8_t>()}).first->second;
+  NSBrowserM.insert({"setTitle:ofColumn:", 0});
+
+  // UIAccessibilityElement Methods
+  llvm::StringMap<uint8_t> &UIAccessibilityElementM =
+      UIMethods.insert({"UIAccessibilityElement", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIAccessibilityElementM.insert({"setAccessibilityLabel:", 0});
+  UIAccessibilityElementM.insert({"setAccessibilityHint:", 0});
+  UIAccessibilityElementM.insert({"setAccessibilityValue:", 0});
 
   // UIAlertAction Methods
   llvm::StringMap<uint8_t> &UIAlertActionM =

           .first->second;
   UIAlertActionM.insert({"actionWithTitle:style:handler:", 0});
 
+  // NSPopUpButton Methods
+  llvm::StringMap<uint8_t> &NSPopUpButtonM =
+      UIMethods.insert({"NSPopUpButton", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSPopUpButtonM.insert({"addItemWithTitle:", 0});
+  NSPopUpButtonM.insert({"insertItemWithTitle:atIndex:", 0});
+  NSPopUpButtonM.insert({"removeItemWithTitle:", 0});
+  NSPopUpButtonM.insert({"selectItemWithTitle:", 0});
+  NSPopUpButtonM.insert({"setTitle:", 0});
+
+  // NSTableViewRowAction Methods
+  llvm::StringMap<uint8_t> &NSTableViewRowActionM =
+      UIMethods.insert({"NSTableViewRowAction", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSTableViewRowActionM.insert({"rowActionWithStyle:title:handler:", 1});
+  NSTableViewRowActionM.insert({"setTitle:", 0});
+
+  // NSImage Methods
+  llvm::StringMap<uint8_t> &NSImageM =
+      UIMethods.insert({"NSImage", llvm::StringMap<uint8_t>()}).first->second;
+  NSImageM.insert({"setAccessibilityDescription:", 0});
+
+  // NSUserActivity Methods
+  llvm::StringMap<uint8_t> &NSUserActivityM =
+      UIMethods.insert({"NSUserActivity", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSUserActivityM.insert({"setTitle:", 0});
+
+  // NSPathControlItem Methods
+  llvm::StringMap<uint8_t> &NSPathControlItemM =
+      UIMethods.insert({"NSPathControlItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSPathControlItemM.insert({"setTitle:", 0});
+
+  // NSCell Methods
+  llvm::StringMap<uint8_t> &NSCellM =
+      UIMethods.insert({"NSCell", llvm::StringMap<uint8_t>()}).first->second;
+  NSCellM.insert({"initTextCell:", 0});
+  NSCellM.insert({"setTitle:", 0});
+  NSCellM.insert({"setStringValue:", 0});
+
+  // NSPathControl Methods
+  llvm::StringMap<uint8_t> &NSPathControlM =
+      UIMethods.insert({"NSPathControl", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSPathControlM.insert({"setPlaceholderString:", 0});
+
+  // UIAccessibility Methods
+  llvm::StringMap<uint8_t> &UIAccessibilityM =
+      UIMethods.insert({"UIAccessibility", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIAccessibilityM.insert({"setAccessibilityLabel:", 0});
+  UIAccessibilityM.insert({"setAccessibilityHint:", 0});
+  UIAccessibilityM.insert({"setAccessibilityValue:", 0});
+
+  // NSTableColumn Methods
+  llvm::StringMap<uint8_t> &NSTableColumnM =
+      UIMethods.insert({"NSTableColumn", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSTableColumnM.insert({"setTitle:", 0});
+  NSTableColumnM.insert({"setHeaderToolTip:", 0});
+
+  // NSSegmentedControl Methods
+  llvm::StringMap<uint8_t> &NSSegmentedControlM =
+      UIMethods.insert({"NSSegmentedControl", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSSegmentedControlM.insert({"setLabel:forSegment:", 0});
+
+  // NSButtonCell Methods
+  llvm::StringMap<uint8_t> &NSButtonCellM =
+      UIMethods.insert({"NSButtonCell", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSButtonCellM.insert({"setTitle:", 0});
+  NSButtonCellM.insert({"setAlternateTitle:", 0});
+
+  // NSSliderCell Methods
+  llvm::StringMap<uint8_t> &NSSliderCellM =
+      UIMethods.insert({"NSSliderCell", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSSliderCellM.insert({"setTitle:", 0});
+
+  // NSControl Methods
+  llvm::StringMap<uint8_t> &NSControlM =
+      UIMethods.insert({"NSControl", llvm::StringMap<uint8_t>()}).first->second;
+  NSControlM.insert({"setStringValue:", 0});
+
+  // NSAccessibility Methods
+  llvm::StringMap<uint8_t> &NSAccessibilityM =
+      UIMethods.insert({"NSAccessibility", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSAccessibilityM.insert({"setAccessibilityValueDescription:", 0});
+  NSAccessibilityM.insert({"setAccessibilityLabel:", 0});
+  NSAccessibilityM.insert({"setAccessibilityTitle:", 0});
+  NSAccessibilityM.insert({"setAccessibilityPlaceholderValue:", 0});
+  NSAccessibilityM.insert({"setAccessibilityHelp:", 0});
+
+  // NSMatrix Methods
+  llvm::StringMap<uint8_t> &NSMatrixM =
+      UIMethods.insert({"NSMatrix", llvm::StringMap<uint8_t>()}).first->second;
+  NSMatrixM.insert({"setToolTip:forCell:", 0});
+
+  // NSPrintPanel Methods
+  llvm::StringMap<uint8_t> &NSPrintPanelM =
+      UIMethods.insert({"NSPrintPanel", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSPrintPanelM.insert({"setDefaultButtonTitle:", 0});
+
+  // UILocalNotification Methods
+  llvm::StringMap<uint8_t> &UILocalNotificationM =
+      UIMethods.insert({"UILocalNotification", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UILocalNotificationM.insert({"setAlertBody:", 0});
+  UILocalNotificationM.insert({"setAlertAction:", 0});
+  UILocalNotificationM.insert({"setAlertTitle:", 0});
+
+  // NSSlider Methods
+  llvm::StringMap<uint8_t> &NSSliderM =
+      UIMethods.insert({"NSSlider", llvm::StringMap<uint8_t>()}).first->second;
+  NSSliderM.insert({"setTitle:", 0});
+
+  // UIMenuItem Methods
+  llvm::StringMap<uint8_t> &UIMenuItemM =
+      UIMethods.insert({"UIMenuItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIMenuItemM.insert({"initWithTitle:action:", 0});
+  UIMenuItemM.insert({"setTitle:", 0});
+
   // UIAlertController Methods
   llvm::StringMap<uint8_t> &UIAlertControllerM =
       UIMethods.insert({"UIAlertController", llvm::StringMap<uint8_t>()})
           .first->second;
   UIAlertControllerM.insert(
       {"alertControllerWithTitle:message:preferredStyle:", 1});
+  UIAlertControllerM.insert({"setTitle:", 0});
+  UIAlertControllerM.insert({"setMessage:", 0});
 
-  // NSButton Methods
-  llvm::StringMap<uint8_t> &NSButtonM =
-      UIMethods.insert({"NSButton", llvm::StringMap<uint8_t>()}).first->second;
-  NSButtonM.insert({"setTitle:", 0});
+  // UIApplicationShortcutItem Methods
+  llvm::StringMap<uint8_t> &UIApplicationShortcutItemM =
+      UIMethods.insert(
+                   {"UIApplicationShortcutItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIApplicationShortcutItemM.insert(
+      {"initWithType:localizedTitle:localizedSubtitle:icon:userInfo:", 1});
+  UIApplicationShortcutItemM.insert({"initWithType:localizedTitle:", 1});
 
-  // NSButtonCell Methods
-  llvm::StringMap<uint8_t> &NSButtonCellM =
-      UIMethods.insert({"NSButtonCell", llvm::StringMap<uint8_t>()})
+  // UIActionSheet Methods
+  llvm::StringMap<uint8_t> &UIActionSheetM =
+      UIMethods.insert({"UIActionSheet", llvm::StringMap<uint8_t>()})
           .first->second;
-  NSButtonCellM.insert({"setTitle:", 0});
+  UIActionSheetM.insert({"initWithTitle:delegate:cancelButtonTitle:"
+                         "destructiveButtonTitle:otherButtonTitles:",
+                         0});
+  UIActionSheetM.insert({"addButtonWithTitle:", 0});
+  UIActionSheetM.insert({"setTitle:", 0});
+
+  // NSURLSessionTask Methods
+  llvm::StringMap<uint8_t> &NSURLSessionTaskM =
+      UIMethods.insert({"NSURLSessionTask", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSURLSessionTaskM.insert({"setTaskDescription:", 0});
 
-  // NSMenuItem Methods
-  llvm::StringMap<uint8_t> &NSMenuItemM =
-      UIMethods.insert({"NSMenuItem", llvm::StringMap<uint8_t>()})
+  // UIAccessibilityCustomAction Methods
+  llvm::StringMap<uint8_t> &UIAccessibilityCustomActionM =
+      UIMethods.insert(
+                   {"UIAccessibilityCustomAction", llvm::StringMap<uint8_t>()})
           .first->second;
-  NSMenuItemM.insert({"setTitle:", 0});
+  UIAccessibilityCustomActionM.insert({"initWithName:target:selector:", 0});
+  UIAccessibilityCustomActionM.insert({"setName:", 0});
+
+  // UISearchBar Methods
+  llvm::StringMap<uint8_t> &UISearchBarM =
+      UIMethods.insert({"UISearchBar", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UISearchBarM.insert({"setText:", 0});
+  UISearchBarM.insert({"setPrompt:", 0});
+  UISearchBarM.insert({"setPlaceholder:", 0});
+
+  // UIBarItem Methods
+  llvm::StringMap<uint8_t> &UIBarItemM =
+      UIMethods.insert({"UIBarItem", llvm::StringMap<uint8_t>()}).first->second;
+  UIBarItemM.insert({"setTitle:", 0});
+
+  // UITextView Methods
+  llvm::StringMap<uint8_t> &UITextViewM =
+      UIMethods.insert({"UITextView", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UITextViewM.insert({"setText:", 0});
+
+  // NSView Methods
+  llvm::StringMap<uint8_t> &NSViewM =
+      UIMethods.insert({"NSView", llvm::StringMap<uint8_t>()}).first->second;
+  NSViewM.insert({"setToolTip:", 0});
+
+  // NSTextField Methods
+  llvm::StringMap<uint8_t> &NSTextFieldM =
+      UIMethods.insert({"NSTextField", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSTextFieldM.insert({"setPlaceholderString:", 0});
 
   // NSAttributedString Methods
   llvm::StringMap<uint8_t> &NSAttributedStringM =

           .first->second;
   NSAttributedStringM.insert({"initWithString:", 0});
   NSAttributedStringM.insert({"initWithString:attributes:", 0});
+
+  // NSText Methods
+  llvm::StringMap<uint8_t> &NSTextM =
+      UIMethods.insert({"NSText", llvm::StringMap<uint8_t>()}).first->second;
+  NSTextM.insert({"setString:", 0});
+
+  // UIKeyCommand Methods
+  llvm::StringMap<uint8_t> &UIKeyCommandM =
+      UIMethods.insert({"UIKeyCommand", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIKeyCommandM.insert(
+      {"keyCommandWithInput:modifierFlags:action:discoverabilityTitle:", 3});
+  UIKeyCommandM.insert({"setDiscoverabilityTitle:", 0});
+
+  // UILabel Methods
+  llvm::StringMap<uint8_t> &UILabelM =
+      UIMethods.insert({"UILabel", llvm::StringMap<uint8_t>()}).first->second;
+  UILabelM.insert({"setText:", 0});
+
+  // NSAlert Methods
+  llvm::StringMap<uint8_t> &NSAlertM =
+      UIMethods.insert({"NSAlert", llvm::StringMap<uint8_t>()}).first->second;
+  NSAlertM.insert({"alertWithMessageText:defaultButton:alternateButton:"
+                   "otherButton:informativeTextWithFormat:",
+                   0});
+  NSAlertM.insert({"addButtonWithTitle:", 0});
+  NSAlertM.insert({"setMessageText:", 0});
+  NSAlertM.insert({"setInformativeText:", 0});
+  NSAlertM.insert({"setHelpAnchor:", 0});
+
+  // UIMutableApplicationShortcutItem Methods
+  llvm::StringMap<uint8_t> &UIMutableApplicationShortcutItemM =
+      UIMethods.insert({"UIMutableApplicationShortcutItem",
+                        llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIMutableApplicationShortcutItemM.insert({"setLocalizedTitle:", 0});
+  UIMutableApplicationShortcutItemM.insert({"setLocalizedSubtitle:", 0});
+
+  // UIButton Methods
+  llvm::StringMap<uint8_t> &UIButtonM =
+      UIMethods.insert({"UIButton", llvm::StringMap<uint8_t>()}).first->second;
+  UIButtonM.insert({"setTitle:forState:", 0});
+
+  // NSWindow Methods
+  llvm::StringMap<uint8_t> &NSWindowM =
+      UIMethods.insert({"NSWindow", llvm::StringMap<uint8_t>()}).first->second;
+  NSWindowM.insert({"setTitle:", 0});
+  NSWindowM.insert({"minFrameWidthWithTitle:styleMask:", 0});
+  NSWindowM.insert({"setMiniwindowTitle:", 0});
+
+  // NSPathCell Methods
+  llvm::StringMap<uint8_t> &NSPathCellM =
+      UIMethods.insert({"NSPathCell", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSPathCellM.insert({"setPlaceholderString:", 0});
+
+  // UIDocumentMenuViewController Methods
+  llvm::StringMap<uint8_t> &UIDocumentMenuViewControllerM =
+      UIMethods.insert(
+                   {"UIDocumentMenuViewController", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIDocumentMenuViewControllerM.insert(
+      {"addOptionWithTitle:image:order:handler:", 0});
+
+  // UINavigationItem Methods
+  llvm::StringMap<uint8_t> &UINavigationItemM =
+      UIMethods.insert({"UINavigationItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UINavigationItemM.insert({"initWithTitle:", 0});
+  UINavigationItemM.insert({"setTitle:", 0});
+  UINavigationItemM.insert({"setPrompt:", 0});
+
+  // UIAlertView Methods
+  llvm::StringMap<uint8_t> &UIAlertViewM =
+      UIMethods.insert({"UIAlertView", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIAlertViewM.insert(
+      {"initWithTitle:message:delegate:cancelButtonTitle:otherButtonTitles:",
+       0});
+  UIAlertViewM.insert({"addButtonWithTitle:", 0});
+  UIAlertViewM.insert({"setTitle:", 0});
+  UIAlertViewM.insert({"setMessage:", 0});
+
+  // NSFormCell Methods
+  llvm::StringMap<uint8_t> &NSFormCellM =
+      UIMethods.insert({"NSFormCell", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSFormCellM.insert({"initTextCell:", 0});
+  NSFormCellM.insert({"setTitle:", 0});
+  NSFormCellM.insert({"setPlaceholderString:", 0});
+
+  // NSUserNotification Methods
+  llvm::StringMap<uint8_t> &NSUserNotificationM =
+      UIMethods.insert({"NSUserNotification", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSUserNotificationM.insert({"setTitle:", 0});
+  NSUserNotificationM.insert({"setSubtitle:", 0});
+  NSUserNotificationM.insert({"setInformativeText:", 0});
+  NSUserNotificationM.insert({"setActionButtonTitle:", 0});
+  NSUserNotificationM.insert({"setOtherButtonTitle:", 0});
+  NSUserNotificationM.insert({"setResponsePlaceholder:", 0});
+
+  // NSToolbarItem Methods
+  llvm::StringMap<uint8_t> &NSToolbarItemM =
+      UIMethods.insert({"NSToolbarItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSToolbarItemM.insert({"setLabel:", 0});
+  NSToolbarItemM.insert({"setPaletteLabel:", 0});
+  NSToolbarItemM.insert({"setToolTip:", 0});
+
+  // NSProgress Methods
+  llvm::StringMap<uint8_t> &NSProgressM =
+      UIMethods.insert({"NSProgress", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSProgressM.insert({"setLocalizedDescription:", 0});
+  NSProgressM.insert({"setLocalizedAdditionalDescription:", 0});
+
+  // NSSegmentedCell Methods
+  llvm::StringMap<uint8_t> &NSSegmentedCellM =
+      UIMethods.insert({"NSSegmentedCell", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSSegmentedCellM.insert({"setLabel:forSegment:", 0});
+  NSSegmentedCellM.insert({"setToolTip:forSegment:", 0});
+
+  // NSUndoManager Methods
+  llvm::StringMap<uint8_t> &NSUndoManagerM =
+      UIMethods.insert({"NSUndoManager", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSUndoManagerM.insert({"setActionName:", 0});
+  NSUndoManagerM.insert({"undoMenuTitleForUndoActionName:", 0});
+  NSUndoManagerM.insert({"redoMenuTitleForUndoActionName:", 0});
+
+  // NSMenuItem Methods
+  llvm::StringMap<uint8_t> &NSMenuItemM =
+      UIMethods.insert({"NSMenuItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSMenuItemM.insert({"initWithTitle:action:keyEquivalent:", 0});
+  NSMenuItemM.insert({"setTitle:", 0});
+  NSMenuItemM.insert({"setToolTip:", 0});
+
+  // NSPopUpButtonCell Methods
+  llvm::StringMap<uint8_t> &NSPopUpButtonCellM =
+      UIMethods.insert({"NSPopUpButtonCell", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSPopUpButtonCellM.insert({"initTextCell:pullsDown:", 0});
+  NSPopUpButtonCellM.insert({"addItemWithTitle:", 0});
+  NSPopUpButtonCellM.insert({"insertItemWithTitle:atIndex:", 0});
+  NSPopUpButtonCellM.insert({"removeItemWithTitle:", 0});
+  NSPopUpButtonCellM.insert({"selectItemWithTitle:", 0});
+  NSPopUpButtonCellM.insert({"setTitle:", 0});
+
+  // NSViewController Methods
+  llvm::StringMap<uint8_t> &NSViewControllerM =
+      UIMethods.insert({"NSViewController", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSViewControllerM.insert({"setTitle:", 0});
+
+  // NSMenu Methods
+  llvm::StringMap<uint8_t> &NSMenuM =
+      UIMethods.insert({"NSMenu", llvm::StringMap<uint8_t>()}).first->second;
+  NSMenuM.insert({"initWithTitle:", 0});
+  NSMenuM.insert({"insertItemWithTitle:action:keyEquivalent:atIndex:", 0});
+  NSMenuM.insert({"addItemWithTitle:action:keyEquivalent:", 0});
+  NSMenuM.insert({"setTitle:", 0});
+
+  // UIMutableUserNotificationAction Methods
+  llvm::StringMap<uint8_t> &UIMutableUserNotificationActionM =
+      UIMethods.insert({"UIMutableUserNotificationAction",
+                        llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIMutableUserNotificationActionM.insert({"setTitle:", 0});
+
+  // NSForm Methods
+  llvm::StringMap<uint8_t> &NSFormM =
+      UIMethods.insert({"NSForm", llvm::StringMap<uint8_t>()}).first->second;
+  NSFormM.insert({"addEntry:", 0});
+  NSFormM.insert({"insertEntry:atIndex:", 0});
+
+  // NSTextFieldCell Methods
+  llvm::StringMap<uint8_t> &NSTextFieldCellM =
+      UIMethods.insert({"NSTextFieldCell", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSTextFieldCellM.insert({"setPlaceholderString:", 0});
+
+  // NSUserNotificationAction Methods
+  llvm::StringMap<uint8_t> &NSUserNotificationActionM =
+      UIMethods.insert({"NSUserNotificationAction", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSUserNotificationActionM.insert({"actionWithIdentifier:title:", 1});
+
+  // NSURLSession Methods
+  llvm::StringMap<uint8_t> &NSURLSessionM =
+      UIMethods.insert({"NSURLSession", llvm::StringMap<uint8_t>()})
+          .first->second;
+  NSURLSessionM.insert({"setSessionDescription:", 0});
+
+  // UITextField Methods
+  llvm::StringMap<uint8_t> &UITextFieldM =
+      UIMethods.insert({"UITextField", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UITextFieldM.insert({"setText:", 0});
+  UITextFieldM.insert({"setPlaceholder:", 0});
+
+  // UIBarButtonItem Methods
+  llvm::StringMap<uint8_t> &UIBarButtonItemM =
+      UIMethods.insert({"UIBarButtonItem", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIBarButtonItemM.insert({"initWithTitle:style:target:action:", 0});
+
+  // UIViewController Methods
+  llvm::StringMap<uint8_t> &UIViewControllerM =
+      UIMethods.insert({"UIViewController", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UIViewControllerM.insert({"setTitle:", 0});
+
+  // UISegmentedControl Methods
+  llvm::StringMap<uint8_t> &UISegmentedControlM =
+      UIMethods.insert({"UISegmentedControl", llvm::StringMap<uint8_t>()})
+          .first->second;
+  UISegmentedControlM.insert({"insertSegmentWithTitle:atIndex:animated:", 0});
+  UISegmentedControlM.insert({"setTitle:forSegmentAtIndex:", 0});
 }
 
 /// Initializes a list of methods and C functions that return a localized string

 /// Checks to see if the method / function declaration includes
 /// __attribute__((annotate("returns_localized_nsstring")))
 bool NonLocalizedStringChecker::isAnnotatedAsLocalized(const Decl *D) const {
+  if (!D)
+    return false;
   return std::any_of(
       D->specific_attr_begin<AnnotateAttr>(),
       D->specific_attr_end<AnnotateAttr>(), [](const AnnotateAttr *Ann) {

     return;
 
   // Generate the bug report.
-  std::unique_ptr<BugReport> R(
-      new BugReport(*BT, "String should be localized", ErrNode));
+  std::unique_ptr<BugReport> R(new BugReport(
+      *BT, "User-facing text should use localized string macro", ErrNode));
   if (argumentNumber) {
     R->addRange(M.getArgExpr(argumentNumber - 1)->getSourceRange());
   } else {

   C.emitReport(std::move(R));
 }
 
+/// Returns the argument number requiring localized string if it exists
+/// otherwise, returns -1
+int NonLocalizedStringChecker::getLocalizedArgumentForSelector(
+    StringRef Receiver, StringRef SelectorName) const {
+  auto method = UIMethods.find(Receiver);
+
+  if (method == UIMethods.end())
+    return -1;
+
+  auto argumentIterator = method->getValue().find(SelectorName);
+
+  if (argumentIterator == method->getValue().end())
+    return -1;
+
+  int argumentNumber = argumentIterator->getValue();
+  return argumentNumber;
+}
+
 /// Check if the string being passed in has NonLocalized state
 void NonLocalizedStringChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
                                                     CheckerContext &C) const {

   StringRef SelectorName = SelectorString;
   assert(!SelectorName.empty());
 
-  auto method = UIMethods.find(odInfo->getName());
   if (odInfo->isStr("NSString")) {
     // Handle the case where the receiver is an NSString
     // These special NSString methods draw to the screen

     if (isNonLocalized) {
       reportLocalizationError(svTitle, msg, C);
     }
-  } else if (method != UIMethods.end()) {
-
-    auto argumentIterator = method->getValue().find(SelectorName);
+  }
 
-    if (argumentIterator == method->getValue().end())
-      return;
+  int argumentNumber =
+      getLocalizedArgumentForSelector(odInfo->getName(), SelectorName);
+  // Go up each hierarchy of superclasses and their protocols
+  while (argumentNumber < 0 && OD->getSuperClass() != nullptr) {
+    for (const auto *P : OD->all_referenced_protocols()) {
+      argumentNumber = getLocalizedArgumentForSelector(
+          P->getIdentifier()->getName(), SelectorName);
+      if (argumentNumber >= 0)
+        break;
+    }
+    if (argumentNumber < 0) {
+      OD = OD->getSuperClass();
+      argumentNumber = getLocalizedArgumentForSelector(
+          OD->getIdentifier()->getName(), SelectorName);
+    }
+  }
 
-    int argumentNumber = argumentIterator->getValue();
+  if (argumentNumber < 0) // There was no match in UIMethods
+    return;
 
-    SVal svTitle = msg.getArgSVal(argumentNumber);
 
-    if (const ObjCStringRegion *SR =
-            dyn_cast_or_null<ObjCStringRegion>(svTitle.getAsRegion())) {
-      StringRef stringValue =
-          SR->getObjCStringLiteral()->getString()->getString();
-      if ((stringValue.trim().size() == 0 && stringValue.size() > 0) ||
-          stringValue.empty())
-        return;
-      if (!IsAggressive && llvm::sys::unicode::columnWidthUTF8(stringValue) < 2)
-        return;
-    }
 
-    bool isNonLocalized = hasNonLocalizedState(svTitle, C);
 
-    if (isNonLocalized) {
-      reportLocalizationError(svTitle, msg, C, argumentNumber + 1);
-    }
   }
 }
 

 
   const IdentifierInfo *odInfo = OD->getIdentifier();
 
-  if (!(odInfo->isStr("NSBundle") ||
+  if (!(odInfo->isStr("NSBundle") &&
         ME->getSelector().getAsString() ==
             "localizedStringForKey:value:table:")) {
     return;

 void EmptyLocalizationContextChecker::MethodCrawler::reportEmptyContextError(
     const ObjCMessageExpr *ME) const {
   // Generate the bug report.
-  BR.EmitBasicReport(MD, Checker, "Context Missing", "Localizability Error",
+  BR.EmitBasicReport(MD, Checker, "Context Missing",
+                     "Localizability Issue (Apple)",
                      "Localized string macro should include a non-empty "
                      "comment for translators",
                      PathDiagnosticLocation(ME, BR.getSourceManager(), DCtx));
 }
 
+namespace {
+class PluralMisuseChecker : public Checker<check::ASTCodeBody> {
+
+  // A helper class, which walks the AST
+  class MethodCrawler : public RecursiveASTVisitor<MethodCrawler> {
+    BugReporter &BR;
+    const CheckerBase *Checker;
+    AnalysisDeclContext *AC;
+
+    // This functions like a stack. We push on any IfStmt or
+    // ConditionalOperator that matches the condition
+    // and pop it off when we leave that statement
+    llvm::SmallVector<const clang::Stmt *, 8> MatchingStatements;
+    // This is true when we are the direct-child of a
+    // matching statement
+    bool InMatchingStatement = false;
+
+  public:
+    explicit MethodCrawler(BugReporter &InBR, const CheckerBase *Checker,
+                           AnalysisDeclContext *InAC)
+        : BR(InBR), Checker(Checker), AC(InAC) {}
+
+    bool VisitIfStmt(const IfStmt *I);
+    bool TraverseIfStmt(IfStmt *x);
+    bool VisitConditionalOperator(const ConditionalOperator *C);
+    bool TraverseConditionalOperator(ConditionalOperator *C);
+    bool VisitCallExpr(const CallExpr *CE);
+    bool VisitObjCMessageExpr(const ObjCMessageExpr *ME);
+
+  private:
+    void reportPluralMisuseError(const Stmt *S) const;
+    bool isCheckingPlurality(const Expr *E) const;
+  };
+
+public:
+  void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
+                        BugReporter &BR) const {
+    MethodCrawler Visitor(BR, this, Mgr.getAnalysisDeclContext(D));
+    Visitor.TraverseDecl(const_cast<Decl *>(D));
+  }
+};
+} // end anonymous namespace
+
+// Checks the condition of the IfStmt and returns true if one
+// of the following heuristics are met:
+// 1) The conidtion is a variable with "singular" or "plural" in the name
+// 2) The condition is a binary operator with 1 or 2 on the right-hand side
+bool PluralMisuseChecker::MethodCrawler::isCheckingPlurality(
+    const Expr *Condition) const {
+  const BinaryOperator *BO = nullptr;
+  // Accounts for when a VarDecl represents a BinaryOperator
+  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Condition)) {
+    if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
+      const Expr *InitExpr = VD->getInit();
+      if (InitExpr) {
+        if (const BinaryOperator *B =
+                dyn_cast<BinaryOperator>(InitExpr->IgnoreParenImpCasts())) {
+          BO = B;
+        }
+      }
+      if (VD->getName().lower().find("plural") != StringRef::npos ||
+          VD->getName().lower().find("singular") != StringRef::npos) {
+        return true;
+      }
+    }
+  } else if (const BinaryOperator *B = dyn_cast<BinaryOperator>(Condition)) {
+    BO = B;
+  }
+
+  if (BO == nullptr)
+    return false;
+
+  if (IntegerLiteral *IL = dyn_cast_or_null<IntegerLiteral>(
+          BO->getRHS()->IgnoreParenImpCasts())) {
+    llvm::APInt Value = IL->getValue();
+    if (Value == 1 || Value == 2) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// A CallExpr with "LOC" in its identifier that takes in a string literal
+// has been shown to almost always be a function that returns a localized
+// string. Raise a diagnostic when this is in a statement that matches
+// the condition.
+bool PluralMisuseChecker::MethodCrawler::VisitCallExpr(const CallExpr *CE) {
+  if (InMatchingStatement) {
+    if (const FunctionDecl *FD = CE->getDirectCallee()) {
+      StringRef NormalizedName =
+          StringRef(FD->getNameInfo().getAsString()).lower();
+      if (NormalizedName.find("loc") != StringRef::npos) {
+        for (const Expr *Arg : CE->arguments()) {
+          if (isa<ObjCStringLiteral>(Arg))
+            reportPluralMisuseError(CE);
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// The other case is for NSLocalizedString which also returns
+// a localized string. It's a macro for the ObjCMessageExpr
+// [NSBundle localizedStringForKey:value:table:] Raise a
+// diagnostic when this is in a statement that matches
+// the condition.
+bool PluralMisuseChecker::MethodCrawler::VisitObjCMessageExpr(
+    const ObjCMessageExpr *ME) {
+  const ObjCInterfaceDecl *OD = ME->getReceiverInterface();
+  if (!OD)
+    return true;
+
+  const IdentifierInfo *odInfo = OD->getIdentifier();
+
+  if (odInfo->isStr("NSBundle") &&
+      ME->getSelector().getAsString() == "localizedStringForKey:value:table:") {
+    if (InMatchingStatement) {
+      reportPluralMisuseError(ME);
+    }
+  }
+  return true;
+}
+
+/// Override TraverseIfStmt so we know when we are done traversing an IfStmt
+bool PluralMisuseChecker::MethodCrawler::TraverseIfStmt(IfStmt *I) {
+  RecursiveASTVisitor<MethodCrawler>::TraverseIfStmt(I);
+  MatchingStatements.pop_back();
+  if (!MatchingStatements.empty()) {
+    if (MatchingStatements.back() != nullptr) {
+      InMatchingStatement = true;
+      return true;
+    }
+  }
+  InMatchingStatement = false;
+  return true;
+}
+
+bool PluralMisuseChecker::MethodCrawler::VisitIfStmt(const IfStmt *I) {
+  const Expr *Condition = I->getCond()->IgnoreParenImpCasts();
+  if (isCheckingPlurality(Condition)) {
+    MatchingStatements.push_back(I);
+    InMatchingStatement = true;
+  } else {
+    MatchingStatements.push_back(nullptr);
+    InMatchingStatement = false;
+  }
+
+  return true;
+}
+
+// Preliminary support for conditional operators.
+bool PluralMisuseChecker::MethodCrawler::TraverseConditionalOperator(
+    ConditionalOperator *C) {
+  RecursiveASTVisitor<MethodCrawler>::TraverseConditionalOperator(C);
+  MatchingStatements.pop_back();
+  if (!MatchingStatements.empty()) {
+    if (MatchingStatements.back() != nullptr)
+      InMatchingStatement = true;
+    else
+      InMatchingStatement = false;
+  } else {
+    InMatchingStatement = false;
+  }
+  return true;
+}
+
+bool PluralMisuseChecker::MethodCrawler::VisitConditionalOperator(
+    const ConditionalOperator *C) {
+  const Expr *Condition = C->getCond()->IgnoreParenImpCasts();
+  if (isCheckingPlurality(Condition)) {
+    MatchingStatements.push_back(C);
+    InMatchingStatement = true;
+  } else {
+    MatchingStatements.push_back(nullptr);
+    InMatchingStatement = false;
+  }
+  return true;
+}
+
+void PluralMisuseChecker::MethodCrawler::reportPluralMisuseError(
+    const Stmt *S) const {
+  // Generate the bug report.
+  BR.EmitBasicReport(AC->getDecl(), Checker, "Plural Misuse",
+                     "Localizability Issue (Apple)",
+                     "Plural cases are not supported accross all languages. "
+                     "Use a .stringsdict file instead",
+                     PathDiagnosticLocation(S, BR.getSourceManager(), AC));
+}
+
 //===----------------------------------------------------------------------===//
 // Checker registration.
 //===----------------------------------------------------------------------===//

 void ento::registerEmptyLocalizationContextChecker(CheckerManager &mgr) {
   mgr.registerChecker<EmptyLocalizationContextChecker>();
 }
+
+void ento::registerPluralMisuseChecker(CheckerManager &mgr) {
+  mgr.registerChecker<PluralMisuseChecker>();
+}
 No newline at end of file

test/Analysis/localization-aggressive.m

                               value:(NSString *)value
                               table:(NSString *)tableName;
 @end
-@interface UILabel : NSObject
-@property(nullable, nonatomic, copy) NSString *text;
+@protocol UIAccessibility 
 - (void)accessibilitySetIdentification:(NSString *)ident;
+- (void)setAccessibilityLabel:(NSString *)label;
+@end
+@interface UILabel : NSObject <UIAccessibility>
+@property(nullable, nonatomic, copy) NSString *text;
 @end
 @interface TestObject : NSObject
 @property(strong) NSString *text;
 @end
+@interface NSView : NSObject
+@property (strong) NSString *toolTip;
+@end
+@interface NSViewSubclass : NSView
+@end
 
 @interface LocalizationTestSuite : NSObject
 NSString *ForceLocalized(NSString *str)

     bar = @"Unlocalized string";
   }
 
-  [testLabel setText:bar]; // expected-warning {{String should be localized}}
+  [testLabel setText:bar]; // expected-warning {{User-facing text should use localized string macro}}
 }
 
 - (void)testLocalizationErrorDetectedOnNSString {

     bar = @"Unlocalized string";
   }
 
-  [bar drawAtPoint:CGPointMake(0, 0) withAttributes:nil]; // expected-warning {{String should be localized}}
+  [bar drawAtPoint:CGPointMake(0, 0) withAttributes:nil]; // expected-warning {{User-facing text should use localized string macro}}
 }
 
 - (void)testNoLocalizationErrorDetectedFromCFunction {

 // An string literal @"Hello" inline should raise an error
 - (void)testInlineStringLiteralHasLocalizedState {
   UILabel *testLabel = [[UILabel alloc] init];
-  [testLabel setText:@"Hello"]; // expected-warning {{String should be localized}}
+  [testLabel setText:@"Hello"]; // expected-warning {{User-facing text should use localized string macro}}
 }
 
 // A nil string should not raise an error

 - (void)localizedStringAsArgument:(NSString *)argumentString {
   UILabel *testLabel = [[UILabel alloc] init];
 
-  [testLabel setText:argumentString]; // expected-warning {{String should be localized}}
+  [testLabel setText:argumentString]; // expected-warning {{User-facing text should use localized string macro}}
 }
 
 // [LocalizationTestSuite unLocalizedStringMethod] returns an unlocalized string

   UILabel *testLabel = [[UILabel alloc] init];
   NSString *bar = NSLocalizedString(@"Hello", @"Comment");
 
-  [testLabel setText:[LocalizationTestSuite unLocalizedStringMethod]]; // expected-warning {{String should be localized}}
+  [testLabel setText:[LocalizationTestSuite unLocalizedStringMethod]]; // expected-warning {{User-facing text should use localized string macro}}
 }
 
 // This is the reverse situation: accessibilitySetIdentification: doesn't care

   [testLabel accessibilitySetIdentification:@"UnlocalizedString"]; // no-warning
 }
 
+// An NSView subclass should raise a warning for methods in NSView that 
+// require localized strings 
+- (void)testRequiresLocalizationMethodFromSuperclass {
+  NSViewSubclass *s = [[NSViewSubclass alloc] init];
+  NSString *bar = @"UnlocalizedString";
+
+  [s setToolTip:bar]; // expected-warning {{User-facing text should use localized string macro}}
+}
+
+- (void)testRequiresLocalizationMethodFromProtocol {
+  UILabel *testLabel = [[UILabel alloc] init];
+
+  [testLabel setAccessibilityLabel:@"UnlocalizedString"]; // expected-warning {{User-facing text should use localized string macro}}
+}
+
 // EmptyLocalizationContextChecker tests
 #define HOM(s) YOLOC(s)
 #define YOLOC(x) NSLocalizedString(x, nil)

test/Analysis/localization.m

-// RUN: %clang_cc1 -analyze -fblocks -analyzer-store=region -analyzer-checker=alpha.osx.cocoa.NonLocalizedStringChecker -analyzer-checker=alpha.osx.cocoa.EmptyLocalizationContextChecker -verify  %s
+// RUN: %clang_cc1 -analyze -fblocks -analyzer-store=region -analyzer-checker=alpha.osx.cocoa.NonLocalizedStringChecker -analyzer-checker=alpha.osx.cocoa.PluralMisuseChecker -verify  %s
 
 // The larger set of tests in located in localization.m. These are tests
 // specific for non-aggressive reporting.

 - (id)init;
 @end
 @interface NSString : NSObject
+- (NSString *)stringByAppendingFormat:(NSString *)format, ...;
++ (instancetype)stringWithFormat:(NSString *)format, ...;
 @end
 @interface NSBundle : NSObject
 + (NSBundle *)mainBundle;

 
 @interface LocalizationTestSuite : NSObject
 int random();
+@property (assign) int unreadArticlesCount;
 @end
-
+#define MCLocalizedString(s) NSLocalizedString(s,nil);
 // Test cases begin here
 @implementation LocalizationTestSuite
 
+NSString *KHLocalizedString(NSString* key, NSString* comment) {
+    return NSLocalizedString(key, comment);
+}
+
 // An object passed in as an parameter's string member
 // should not be considered unlocalized
 - (void)testObjectAsArgument:(TestObject *)argumentObject {

     bar = @"Unlocalized string";
   }
 
-  [testLabel setText:bar]; // expected-warning {{String should be localized}}
+  [testLabel setText:bar]; // expected-warning {{User-facing text should use localized string macro}}
 }
 
 - (void)testOneCharacterStringsDoNotGiveAWarning {

   [testLabel setText:bar]; // no-warning
 }
 
+// Plural Misuse Checker Tests
+// These tests are modeled off incorrect uses of the many-one pattern
+// from real projects. 
+
+- (NSString *)test1:(int)plural {
+    if (plural) {
+        return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    }
+    return MCLocalizedString(@"TYPE");
+}
+
+- (NSString *)test2:(int)numOfReminders {
+    if (numOfReminders > 0) {
+        return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    } 
+    return nil;
+}
+
+- (void)test3 {
+    NSString *count;
+    if (self.unreadArticlesCount > 1)
+    {
+        count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    } else {
+        count = [count stringByAppendingFormat:@"%@",  KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    }
+}
+
+- (NSString *)test4:(int)count {
+    if ( count == 1 )
+    {
+        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    } else {
+        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    }
+}
+
+- (NSString *)test5:(int)count {
+  int test = count == 1;
+    if (test)
+    {
+        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    } else {
+        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    }
+}
+
+// This tests the heuristic that the direct parent IfStmt must match the isCheckingPlurality confition to avoid false positives generated from complex code (generally the pattern we're looking for is simple If-Else)
+
+- (NSString *)test6:(int)sectionIndex {
+  int someOtherVariable = 0;
+    if (sectionIndex == 1)
+    {
+    // Do some other crazy stuff
+    if (someOtherVariable)
+          return KHLocalizedString(@"OK",nil); // no-warning
+    } else {
+        return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}}
+    }
+  return nil;
+}
+
+// False positives that we are not accounting for involve matching the heuristic
+// of having 1 or 2 in the RHS of a BinaryOperator and having a localized string 
+// in the body of the IfStmt. This is seen a lot when checking for the section
+// indexpath of something like a UITableView
+
+// - (NSString *)testNotAccountedFor:(int)sectionIndex {
+//     if (sectionIndex == 1)
+//     {
+//         return KHLocalizedString(@"1",nil); // false-positive
+//     } else if (sectionIndex == 2) {
+//      return KHLocalizedString(@"2",nil); // false-positive
+//     } else if (sectionIndex == 3) {
+//    return KHLocalizedString(@"3",nil); // no-false-positive
+//  }
+// }
+
+// Potential test-cases to support in the future
+
+// - (NSString *)test7:(int)count {
+//     BOOL plural = count != 1;
+//     return KHLocalizedString(plural ? @"PluralString" : @"SingularString", @"");
+// }
+//
+// - (NSString *)test8:(BOOL)plural {
+//     return KHLocalizedString(([NSString stringWithFormat:@"RELATIVE_DATE_%@_%@", ((1 == 1) ? @"FUTURE" : @"PAST"), plural ? @"PLURAL" : @"SINGULAR"]));
+// }
+//
+//
+//
+// - (void)test9:(int)numberOfTimesEarned {
+//     NSString* localizedDescriptionKey;
+//     if (numberOfTimesEarned == 1) {
+//         localizedDescriptionKey = @"SINGULAR_%@";
+//     } else {
+//         localizedDescriptionKey = @"PLURAL_%@_%@";
+//     }
+//     NSLocalizedString(localizedDescriptionKey, nil);
+// }
+//
+// - (NSString *)test10 {
+//     NSInteger count = self.problems.count;
+//     NSString *title = [NSString stringWithFormat:@"%ld Problems", (long) count];
+//     if (count < 2) {
+//         if (count == 0) {
+//             title = [NSString stringWithFormat:@"No Problems Found"];
+//         } else {
+//             title = [NSString stringWithFormat:@"%ld Problem", (long) count];
+//         }
+//     }
+//     return title;
+// }
+
 @end