[Parse] [Sema] Update confusables diagnostic to mention the character names as well (#33105)

* [Parser] Update 'Confusables.def' file to include confusable and base character names

* [Parser] Add a new utility method to return the names of the confusable and base characters for a given confusable codepoint

* [Parser] Update diagnostic for confusable character during lexing to mention confusable and base character names

* [Sema] If there is just a single confusable character, emit a tailored diagnostic that also mentions the character names

* [Diagnostics] Add new diagnostic messages to the localization file

* [Test] Update confusables test

* [Utils] Update unicode confusables txt file and update script to regenerate confusables def file

* [Parse] Regenerate 'Confusables.def' using updated script

* [Utils] Adjust generate_confusables script based on review feedback

Fix a mistake with name mapping. Updated header comment. Fix a couple of linting issues.

* [Parse] Regenerate 'Confusables.def' file once again after script changes

* [Parse] Add the newline after end of 'getConfusableAndBaseCodepointNames' method

* [Test] Update diagnostic message in 'Syntax/Parser/diags.swift'

Author: theblixguy

include/swift/AST/DiagnosticsParse.def

@@ -112,8 +112,8 @@ ERROR(lex_single_quote_string,none,
 ERROR(lex_invalid_curly_quote,none,
       "unicode curly quote found, replace with '\"'", ())
 NOTE(lex_confusable_character,none,
-      "unicode character '%0' looks similar to '%1'; did you mean to use '%1'?",
-      (StringRef, StringRef))
+      "unicode character '%0' (%1) looks similar to '%2' (%3); did you mean to use '%2' (%3)?",
+      (StringRef, StringRef, StringRef, StringRef))
 WARNING(lex_nonbreaking_space,none,
         "non-breaking space (U+00A0) used instead of regular space", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -832,6 +832,9 @@ NOTE(confusable_character,none,
       "%select{identifier|operator}0 '%1' contains possibly confused characters; "
       "did you mean to use '%2'?",
       (bool, StringRef, StringRef))
+NOTE(single_confusable_character,none,
+      "%select{identifier|operator}0 '%1' (%2) looks similar to '%3' (%4); did you mean '%3' (%4)?",
+      (bool, StringRef, StringRef, StringRef, StringRef))
 ERROR(cannot_find_type_in_scope,none,
       "cannot find type %0 in scope", (DeclNameRef))
 ERROR(cannot_find_type_in_scope_did_you_mean,none,

include/swift/Parse/Confusables.def

@@ -2,127 +2,135 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 
-// CONFUSABLE(CONFUSABLE_POINT, BASEPOINT)
+////////////////////////////////////////////////////////////////////////////////
+// WARNING: This file is manually generated from
+// utils/UnicodeData/confusables.txt and should not be directly modified.
+// Run utils/generate_confusables.py to regenerate this file.
+////////////////////////////////////////////////////////////////////////////////
 
-CONFUSABLE(0x2010, 0x2d)
-CONFUSABLE(0x2011, 0x2d)
-CONFUSABLE(0x2012, 0x2d)
-CONFUSABLE(0x2013, 0x2d)
-CONFUSABLE(0xfe58, 0x2d)
-CONFUSABLE(0x6d4, 0x2d)
-CONFUSABLE(0x2043, 0x2d)
-CONFUSABLE(0x2d7, 0x2d)
-CONFUSABLE(0x2212, 0x2d)
-CONFUSABLE(0x2796, 0x2d)
-CONFUSABLE(0x2cba, 0x2d)
-CONFUSABLE(0x60d, 0x2c)
-CONFUSABLE(0x66b, 0x2c)
-CONFUSABLE(0x201a, 0x2c)
-CONFUSABLE(0xb8, 0x2c)
-CONFUSABLE(0xa4f9, 0x2c)
-CONFUSABLE(0x903, 0x3a)
-CONFUSABLE(0xa83, 0x3a)
-CONFUSABLE(0xff1a, 0x3a)
-CONFUSABLE(0x589, 0x3a)
-CONFUSABLE(0x703, 0x3a)
-CONFUSABLE(0x704, 0x3a)
-CONFUSABLE(0x16ec, 0x3a)
-CONFUSABLE(0xfe30, 0x3a)
-CONFUSABLE(0x1803, 0x3a)
-CONFUSABLE(0x1809, 0x3a)
-CONFUSABLE(0x205a, 0x3a)
-CONFUSABLE(0x5c3, 0x3a)
-CONFUSABLE(0x2f8, 0x3a)
-CONFUSABLE(0xa789, 0x3a)
-CONFUSABLE(0x2236, 0x3a)
-CONFUSABLE(0x2d0, 0x3a)
-CONFUSABLE(0xa4fd, 0x3a)
-CONFUSABLE(0xff01, 0x21)
-CONFUSABLE(0x1c3, 0x21)
-CONFUSABLE(0x2d51, 0x21)
-CONFUSABLE(0x294, 0x3f)
-CONFUSABLE(0x241, 0x3f)
-CONFUSABLE(0x97d, 0x3f)
-CONFUSABLE(0x13ae, 0x3f)
-CONFUSABLE(0xa6eb, 0x3f)
-CONFUSABLE(0x1d16d, 0x2e)
-CONFUSABLE(0x2024, 0x2e)
-CONFUSABLE(0x701, 0x2e)
-CONFUSABLE(0x702, 0x2e)
-CONFUSABLE(0xa60e, 0x2e)
-CONFUSABLE(0x10a50, 0x2e)
-CONFUSABLE(0x660, 0x2e)
-CONFUSABLE(0x6f0, 0x2e)
-CONFUSABLE(0xa4f8, 0x2e)
-CONFUSABLE(0xff3b, 0x28)
-CONFUSABLE(0x2768, 0x28)
-CONFUSABLE(0x2772, 0x28)
-CONFUSABLE(0x3014, 0x28)
-CONFUSABLE(0xfd3e, 0x28)
-CONFUSABLE(0xff3d, 0x29)
-CONFUSABLE(0x2769, 0x29)
-CONFUSABLE(0x2773, 0x29)
-CONFUSABLE(0x3015, 0x29)
-CONFUSABLE(0xfd3f, 0x29)
-CONFUSABLE(0x2774, 0x7b)
-CONFUSABLE(0x1d114, 0x7b)
-CONFUSABLE(0x2775, 0x7d)
-CONFUSABLE(0x204e, 0x2a)
-CONFUSABLE(0x66d, 0x2a)
-CONFUSABLE(0x2217, 0x2a)
-CONFUSABLE(0x1031f, 0x2a)
-CONFUSABLE(0x1735, 0x2f)
-CONFUSABLE(0x2041, 0x2f)
-CONFUSABLE(0x2215, 0x2f)
-CONFUSABLE(0x2044, 0x2f)
-CONFUSABLE(0x2571, 0x2f)
-CONFUSABLE(0x27cb, 0x2f)
-CONFUSABLE(0x29f8, 0x2f)
-CONFUSABLE(0x1d23a, 0x2f)
-CONFUSABLE(0x31d3, 0x2f)
-CONFUSABLE(0x3033, 0x2f)
-CONFUSABLE(0x2cc6, 0x2f)
-CONFUSABLE(0x30ce, 0x2f)
-CONFUSABLE(0x4e3f, 0x2f)
-CONFUSABLE(0x2f03, 0x2f)
-CONFUSABLE(0xff3c, 0x5c)
-CONFUSABLE(0xfe68, 0x5c)
-CONFUSABLE(0x2216, 0x5c)
-CONFUSABLE(0x27cd, 0x5c)
-CONFUSABLE(0x29f5, 0x5c)
-CONFUSABLE(0x29f9, 0x5c)
-CONFUSABLE(0x1d20f, 0x5c)
-CONFUSABLE(0x1d23b, 0x5c)
-CONFUSABLE(0x31d4, 0x5c)
-CONFUSABLE(0x4e36, 0x5c)
-CONFUSABLE(0x2f02, 0x5c)
-CONFUSABLE(0xa778, 0x26)
-CONFUSABLE(0x16ed, 0x2b)
-CONFUSABLE(0x2795, 0x2b)
-CONFUSABLE(0x1029b, 0x2b)
-CONFUSABLE(0x2039, 0x3c)
-CONFUSABLE(0x276e, 0x3c)
-CONFUSABLE(0x2c2, 0x3c)
-CONFUSABLE(0x1d236, 0x3c)
-CONFUSABLE(0x1438, 0x3c)
-CONFUSABLE(0x16b2, 0x3c)
-CONFUSABLE(0x1400, 0x3d)
-CONFUSABLE(0x2e40, 0x3d)
-CONFUSABLE(0x30a0, 0x3d)
-CONFUSABLE(0xa4ff, 0x3d)
-CONFUSABLE(0x203a, 0x3e)
-CONFUSABLE(0x276f, 0x3e)
-CONFUSABLE(0x2c3, 0x3e)
-CONFUSABLE(0x1d237, 0x3e)
-CONFUSABLE(0x1433, 0x3e)
-CONFUSABLE(0x037e, 0x3b)
+
+// CONFUSABLE(CONFUSABLE_POINT, CONFUSABLE_NAME, BASE_POINT, BASE_NAME)
+
+CONFUSABLE(0x2010, "Hyphen", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2011, "Non-Breaking Hyphen", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2012, "Figure Dash", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2013, "En Dash", 0x2d, "Hyphen Minus")
+CONFUSABLE(0xfe58, "Small Em Dash", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x6d4, "Arabic Full Stop", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2043, "Hyphen Bullet", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2d7, "Modifier Letter Minus Sign", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2212, "Minus Sign", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2796, "Heavy Minus Sign", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x2cba, "Coptic Capital Letter Dialect-P Ni", 0x2d, "Hyphen Minus")
+CONFUSABLE(0x60d, "Arabic Date Separator", 0x2c, "Comma")
+CONFUSABLE(0x66b, "Arabic Decimal Separator", 0x2c, "Comma")
+CONFUSABLE(0x201a, "Single Low-9 Quotation Mark", 0x2c, "Comma")
+CONFUSABLE(0xb8, "Cedilla", 0x2c, "Comma")
+CONFUSABLE(0xa4f9, "Lisu Letter Tone Na Po", 0x2c, "Comma")
+CONFUSABLE(0x37e, "Greek Question Mark", 0x3b, "Semicolon")
+CONFUSABLE(0x903, "Devanagari Sign Visarga", 0x3a, "Colon")
+CONFUSABLE(0xa83, "Gujarati Sign Visarga", 0x3a, "Colon")
+CONFUSABLE(0xff1a, "Fullwidth Colon", 0x3a, "Colon")
+CONFUSABLE(0x589, "Armenian Full Stop", 0x3a, "Colon")
+CONFUSABLE(0x703, "Syriac Supralinear Colon", 0x3a, "Colon")
+CONFUSABLE(0x704, "Syriac Sublinear Colon", 0x3a, "Colon")
+CONFUSABLE(0x16ec, "Runic Multiple Punctuation", 0x3a, "Colon")
+CONFUSABLE(0xfe30, "Presentation Form For Vertical Two Dot Leader", 0x3a, "Colon")
+CONFUSABLE(0x1803, "Mongolian Full Stop", 0x3a, "Colon")
+CONFUSABLE(0x1809, "Mongolian Manchu Full Stop", 0x3a, "Colon")
+CONFUSABLE(0x205a, "Two Dot Punctuation", 0x3a, "Colon")
+CONFUSABLE(0x5c3, "Hebrew Punctuation Sof Pasuq", 0x3a, "Colon")
+CONFUSABLE(0x2f8, "Modifier Letter Raised Colon", 0x3a, "Colon")
+CONFUSABLE(0xa789, "Modifier Letter Colon", 0x3a, "Colon")
+CONFUSABLE(0x2236, "Ratio", 0x3a, "Colon")
+CONFUSABLE(0x2d0, "Modifier Letter Triangular Colon", 0x3a, "Colon")
+CONFUSABLE(0xa4fd, "Lisu Letter Tone Mya Jeu", 0x3a, "Colon")
+CONFUSABLE(0xff01, "Fullwidth Exclamation Mark", 0x21, "Exclamation Mark")
+CONFUSABLE(0x1c3, "Latin Letter Retroflex Click", 0x21, "Exclamation Mark")
+CONFUSABLE(0x2d51, "Tifinagh Letter Tuareg Yang", 0x21, "Exclamation Mark")
+CONFUSABLE(0x294, "Latin Letter Glottal Stop", 0x3f, "Question Mark")
+CONFUSABLE(0x241, "Latin Capital Letter Glottal Stop", 0x3f, "Question Mark")
+CONFUSABLE(0x97d, "Devanagari Letter Glottal Stop", 0x3f, "Question Mark")
+CONFUSABLE(0x13ae, "Cherokee Letter He", 0x3f, "Question Mark")
+CONFUSABLE(0xa6eb, "Bamum Letter Ntuu", 0x3f, "Question Mark")
+CONFUSABLE(0x1d16d, "Musical Symbol Combining Augmentation Dot", 0x2e, "Full Stop")
+CONFUSABLE(0x2024, "One Dot Leader", 0x2e, "Full Stop")
+CONFUSABLE(0x701, "Syriac Supralinear Full Stop", 0x2e, "Full Stop")
+CONFUSABLE(0x702, "Syriac Sublinear Full Stop", 0x2e, "Full Stop")
+CONFUSABLE(0xa60e, "Vai Full Stop", 0x2e, "Full Stop")
+CONFUSABLE(0x10a50, "Kharoshthi Punctuation Dot", 0x2e, "Full Stop")
+CONFUSABLE(0x660, "Arabic-Indic Digit Zero", 0x2e, "Full Stop")
+CONFUSABLE(0x6f0, "Extended Arabic-Indic Digit Zero", 0x2e, "Full Stop")
+CONFUSABLE(0xa4f8, "Lisu Letter Tone Mya Ti", 0x2e, "Full Stop")
+CONFUSABLE(0xff3b, "Fullwidth Left Square Bracket", 0x28, "Left Parenthesis")
+CONFUSABLE(0x2768, "Medium Left Parenthesis Ornament", 0x28, "Left Parenthesis")
+CONFUSABLE(0x2772, "Light Left Tortoise Shell Bracket Ornament", 0x28, "Left Parenthesis")
+CONFUSABLE(0x3014, "Left Tortoise Shell Bracket", 0x28, "Left Parenthesis")
+CONFUSABLE(0xfd3e, "Ornate Left Parenthesis", 0x28, "Left Parenthesis")
+CONFUSABLE(0xff3d, "Fullwidth Right Square Bracket", 0x29, "Right Parenthesis")
+CONFUSABLE(0x2769, "Medium Right Parenthesis Ornament", 0x29, "Right Parenthesis")
+CONFUSABLE(0x2773, "Light Right Tortoise Shell Bracket Ornament", 0x29, "Right Parenthesis")
+CONFUSABLE(0x3015, "Right Tortoise Shell Bracket", 0x29, "Right Parenthesis")
+CONFUSABLE(0xfd3f, "Ornate Right Parenthesis", 0x29, "Right Parenthesis")
+CONFUSABLE(0x2774, "Medium Left Curly Bracket Ornament", 0x7b, "Left Curly Bracket")
+CONFUSABLE(0x1d114, "Musical Symbol Brace", 0x7b, "Left Curly Bracket")
+CONFUSABLE(0x2775, "Medium Right Curly Bracket Ornament", 0x7d, "Right Curly Bracket")
+CONFUSABLE(0x204e, "Low Asterisk", 0x2a, "Asterisk")
+CONFUSABLE(0x66d, "Arabic Five Pointed Star", 0x2a, "Asterisk")
+CONFUSABLE(0x2217, "Asterisk Operator", 0x2a, "Asterisk")
+CONFUSABLE(0x1031f, "Old Italic Letter Ess", 0x2a, "Asterisk")
+CONFUSABLE(0x1735, "Philippine Single Punctuation", 0x2f, "Forward Slash")
+CONFUSABLE(0x2041, "Caret Insertion Point", 0x2f, "Forward Slash")
+CONFUSABLE(0x2215, "Division Slash", 0x2f, "Forward Slash")
+CONFUSABLE(0x2044, "Fraction Slash", 0x2f, "Forward Slash")
+CONFUSABLE(0x2571, "Box Drawings Light Diagonal Upper Right To Lower Left", 0x2f, "Forward Slash")
+CONFUSABLE(0x27cb, "Mathematical Rising Diagonal", 0x2f, "Forward Slash")
+CONFUSABLE(0x29f8, "Big Solidus", 0x2f, "Forward Slash")
+CONFUSABLE(0x1d23a, "Greek Instrumental Notation Symbol-47", 0x2f, "Forward Slash")
+CONFUSABLE(0x31d3, "Cjk Stroke Sp", 0x2f, "Forward Slash")
+CONFUSABLE(0x3033, "Vertical Kana Repeat Mark Upper Half", 0x2f, "Forward Slash")
+CONFUSABLE(0x2cc6, "Coptic Capital Letter Old Coptic Esh", 0x2f, "Forward Slash")
+CONFUSABLE(0x30ce, "Katakana Letter No", 0x2f, "Forward Slash")
+CONFUSABLE(0x4e3f, "Cjk Unified Ideograph-4E3F", 0x2f, "Forward Slash")
+CONFUSABLE(0x2f03, "Kangxi Radical Slash", 0x2f, "Forward Slash")
+CONFUSABLE(0xff3c, "Fullwidth Reverse Solidus", 0x5c, "Back Slash")
+CONFUSABLE(0xfe68, "Small Reverse Solidus", 0x5c, "Back Slash")
+CONFUSABLE(0x2216, "Set Minus", 0x5c, "Back Slash")
+CONFUSABLE(0x27cd, "Mathematical Falling Diagonal", 0x5c, "Back Slash")
+CONFUSABLE(0x29f5, "Reverse Solidus Operator", 0x5c, "Back Slash")
+CONFUSABLE(0x29f9, "Big Reverse Solidus", 0x5c, "Back Slash")
+CONFUSABLE(0x1d20f, "Greek Vocal Notation Symbol-16", 0x5c, "Back Slash")
+CONFUSABLE(0x1d23b, "Greek Instrumental Notation Symbol-48", 0x5c, "Back Slash")
+CONFUSABLE(0x31d4, "Cjk Stroke D", 0x5c, "Back Slash")
+CONFUSABLE(0x4e36, "Cjk Unified Ideograph-4E36", 0x5c, "Back Slash")
+CONFUSABLE(0x2f02, "Kangxi Radical Dot", 0x5c, "Back Slash")
+CONFUSABLE(0xa778, "Latin Small Letter Um", 0x26, "Ampersand")
+CONFUSABLE(0x16ed, "Runic Cross Punctuation", 0x2b, "Plus Sign")
+CONFUSABLE(0x2795, "Heavy Plus Sign", 0x2b, "Plus Sign")
+CONFUSABLE(0x1029b, "Lycian Letter H", 0x2b, "Plus Sign")
+CONFUSABLE(0x2039, "Single Left-Pointing Angle Quotation Mark", 0x3c, "Less Than Sign")
+CONFUSABLE(0x276e, "Heavy Left-Pointing Angle Quotation Mark Ornament", 0x3c, "Less Than Sign")
+CONFUSABLE(0x2c2, "Modifier Letter Left Arrowhead", 0x3c, "Less Than Sign")
+CONFUSABLE(0x1d236, "Greek Instrumental Notation Symbol-40", 0x3c, "Less Than Sign")
+CONFUSABLE(0x1438, "Canadian Syllabics Pa", 0x3c, "Less Than Sign")
+CONFUSABLE(0x16b2, "Runic Letter Kauna", 0x3c, "Less Than Sign")
+CONFUSABLE(0x1400, "Canadian Syllabics Hyphen", 0x3d, "Equals Sign")
+CONFUSABLE(0x2e40, "Double Hyphen", 0x3d, "Equals Sign")
+CONFUSABLE(0x30a0, "Katakana-Hiragana Double Hyphen", 0x3d, "Equals Sign")
+CONFUSABLE(0xa4ff, "Lisu Punctuation Full Stop", 0x3d, "Equals Sign")
+CONFUSABLE(0x203a, "Single Right-Pointing Angle Quotation Mark", 0x3e, "Greater Than Sign")
+CONFUSABLE(0x276f, "Heavy Right-Pointing Angle Quotation Mark Ornament", 0x3e, "Greater Than Sign")
+CONFUSABLE(0x2c3, "Modifier Letter Right Arrowhead", 0x3e, "Greater Than Sign")
+CONFUSABLE(0x1d237, "Greek Instrumental Notation Symbol-42", 0x3e, "Greater Than Sign")
+CONFUSABLE(0x1433, "Canadian Syllabics Po", 0x3e, "Greater Than Sign")
+CONFUSABLE(0x16f3f, "Miao Letter Archaic Zza", 0x3e, "Greater Than Sign")
 
 #undef CONFUSABLE

include/swift/Parse/Confusables.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_CONFUSABLES_H
 #define SWIFT_CONFUSABLES_H
 
+#include "llvm/ADT/StringRef.h"
 #include <stdint.h>
 
 namespace swift {
@@ -21,6 +22,12 @@ namespace confusable {
   /// specification table of confusable characters and maps to punctuation,
   /// and either returns either the expected ASCII character or 0.
   char tryConvertConfusableCharacterToASCII(uint32_t codepoint);
+
+  /// Given a UTF-8 codepoint which is previously determined to be confusable,
+  /// return the name of the confusable character and the name of the base
+  /// character.
+  std::pair<llvm::StringRef, llvm::StringRef>
+  getConfusableAndBaseCodepointNames(uint32_t codepoint);
 }
 }
 

lib/Parse/Confusables.cpp

@@ -14,9 +14,22 @@
 
 char swift::confusable::tryConvertConfusableCharacterToASCII(uint32_t codepoint) {
   switch (codepoint) {
-#define CONFUSABLE(CONFUSABLE_POINT, BASEPOINT) \
-  case CONFUSABLE_POINT: return BASEPOINT;
+#define CONFUSABLE(CONFUSABLE_POINT, CONFUSABLE_NAME, BASE_POINT, BASE_NAME)   \
+  case CONFUSABLE_POINT:                                                       \
+    return BASE_POINT;
 #include "swift/Parse/Confusables.def"
   default: return 0;
   }
 }
+
+std::pair<llvm::StringRef, llvm::StringRef>
+swift::confusable::getConfusableAndBaseCodepointNames(uint32_t codepoint) {
+  switch (codepoint) {
+#define CONFUSABLE(CONFUSABLE_POINT, CONFUSABLE_NAME, BASE_POINT, BASE_NAME)   \
+  case CONFUSABLE_POINT:                                                       \
+    return std::make_pair(CONFUSABLE_NAME, BASE_NAME);
+#include "swift/Parse/Confusables.def"
+  default:
+    return std::make_pair("", "");
+  }
+}

lib/Parse/Lexer.cpp

@@ -2097,8 +2097,9 @@ bool Lexer::lexUnknown(bool EmitDiagnosticsIfToken) {
     EncodeToUTF8(Codepoint, ConfusedChar);
     llvm::SmallString<1> ExpectedChar;
     ExpectedChar += ExpectedCodepoint;
+    auto charNames = confusable::getConfusableAndBaseCodepointNames(Codepoint);
     diagnose(CurPtr - 1, diag::lex_confusable_character, ConfusedChar,
-             ExpectedChar)
+             charNames.first, ExpectedChar, charNames.second)
         .fixItReplaceChars(getSourceLoc(CurPtr - 1), getSourceLoc(Tmp),
                            ExpectedChar);
   }

lib/Sema/TypeCheckConstraints.cpp

@@ -525,6 +525,8 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
     llvm::SmallString<64> expectedIdentifier;
     bool isConfused = false;
     uint32_t codepoint;
+    uint32_t firstConfusableCodepoint = 0;
+    int totalCodepoints = 0;
     int offset = 0;
     while ((codepoint = validateUTF8CharacterAndAdvance(buffer,
                                                         buffer +
@@ -533,12 +535,17 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
       int length = (buffer - simpleName.get()) - offset;
       if (auto expectedCodepoint =
           confusable::tryConvertConfusableCharacterToASCII(codepoint)) {
+        if (firstConfusableCodepoint == 0) {
+          firstConfusableCodepoint = codepoint;
+        }
         isConfused = true;
         expectedIdentifier += expectedCodepoint;
       } else {
         expectedIdentifier += (char)codepoint;
       }
 
+      totalCodepoints++;
+
       offset += length;
     }
 
@@ -580,11 +587,21 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
     } else {
       emitBasicError();
 
-      Context.Diags
-          .diagnose(Loc, diag::confusable_character,
-                    UDRE->getName().isOperator(), simpleName.str(),
-                    expectedIdentifier)
-          .fixItReplace(Loc, expectedIdentifier);
+      if (totalCodepoints == 1) {
+        auto charNames = confusable::getConfusableAndBaseCodepointNames(
+            firstConfusableCodepoint);
+        Context.Diags
+            .diagnose(Loc, diag::single_confusable_character,
+                      UDRE->getName().isOperator(), simpleName.str(),
+                      charNames.first, expectedIdentifier, charNames.second)
+            .fixItReplace(Loc, expectedIdentifier);
+      } else {
+        Context.Diags
+            .diagnose(Loc, diag::confusable_character,
+                      UDRE->getName().isOperator(), simpleName.str(),
+                      expectedIdentifier)
+            .fixItReplace(Loc, expectedIdentifier);
+      }
     }
 
     // TODO: consider recovering from here.  We may want some way to suppress