Commits

aarondandy  committed 395797a

various bug fixes and performance enhancments

  • Participants
  • Parent commits 33b057a

Comments (0)

Files changed (25)

File src/YouCantSpell.Core/CachedSpellChecker.cs

 			public CachedSpellCheckData(bool found, string[] suggestions = null)
 			{
 				WordFound = found;
-				Suggestions = Array.AsReadOnly(suggestions ?? new string[0]);
+				Suggestions = null == suggestions ? null : Array.AsReadOnly(suggestions);
 			}
 
 			public readonly bool WordFound;
 
 		/// <inheritdoc/>
 		public bool Check(string word) {
-			return GetRecommendationsCore(word).WordFound;
+			return JustCheckCore(word).WordFound;
+		}
+
+		private CachedSpellCheckData JustCheckCore(string word) {
+			lock (_sync) {
+				CachedSpellCheckData result;
+				if (_cache.TryGetValue(word, out result))
+					return result;
+
+				while (_cache.Count >= _cacheMax)
+					_cache.Remove(_cache.Keys.First());
+
+				_cache[word] = result = new CachedSpellCheckData(_core.Check(word));
+				return result;
+			}
 		}
 
 		/// <inheritdoc/>
 
 		private CachedSpellCheckData GetRecommendationsCore(string word) {
 			lock(_sync) {
-
 				CachedSpellCheckData result;
 				if (_cache.TryGetValue(word, out result))
 				{
 					if (result.Suggestions != null)
-					{
 						return result;
-					}
+
 					_cache[word] = result = new CachedSpellCheckData(result.WordFound, _core.GetRecommendations(word));
 					return result;
 				}

File src/YouCantSpell.Core/SpellChecker.cs

 		}
 
 		/// <inheritdoc/>
-		public bool Check(string word)
-		{
+		public bool Check(string word) {
 			return _core.Spell(word);
 		}
 
 		/// <inheritdoc/>
-		public string[] GetRecommendations(string word)
-		{
+		public string[] GetRecommendations(string word) {
 			return _core.Suggest(word).ToArray();
 		}
 

File src/YouCantSpell.ReSharper.Shared/CSharp/CSharpSpellCheckDaemonStageProcess.cs

 			return typeElement.SuperTypes;
 		}
 
-		[Obsolete]
-		private IEnumerable<string> ParseSuperWords(ITypeElement typeElement) {
-			if (null == typeElement)
-				return Enumerable.Empty<string>();
-
-			return typeElement
-				.GetSuperTypes()
-				.Select(x => ParseNameParts(x.GetClrName().ShortName))
-				.SelectMany(x => x.Select(y => y.SubText))
-				.Distinct();
-		} 
-
 		private IEnumerable<TextSubString> ParseNameParts(string nameText)
 		{
 			var parsedName = ParseName(nameText);
 					|| PrimarySpellChecker.Check(wordPartText)
 				) continue;
 
-				var suggestions = PrimarySpellChecker
+				/*var suggestions = PrimarySpellChecker
 					.GetRecommendations(wordPartText)
 					.Select(x => formatter.FormatSuggestion(x, i))
 					.Distinct()
 					.ToArray();
 
 				if (suggestions.Contains(wordPartText))
-					continue; // its probably OK
+					continue; // its probably OK*/
 
 				var identifierLeftTrim = namePart.Offset + wordPart.Index;
 				var localValidPartRange = (identifierLeftTrim > 0)
 
 				localValidPartRange = localValidPartRange.SetEndTo(localValidPartRange.TextRange.StartOffset + wordPart.Value.Length);
 
+				int wordPosition = i;
 				yield return new HighlightingInfo(
 					localValidPartRange,
-					new CSharpSpellingErrorHighlighting(identifier, localValidPartRange, wordPart.Value, word => suggestions )
+					new CSharpSpellingErrorHighlighting(
+						identifier,
+						localValidPartRange,
+						wordPart.Value,
+						word => PrimarySpellChecker
+							.GetRecommendations(word)
+							.Select(x => formatter.FormatSuggestion(x, wordPosition))
+							.Where(x => word != x)
+							.Distinct()
+							.Take(MaxSuggestions)
+							.ToArray()
+					)
 				);
 			}
 

File src/YouCantSpell.ReSharper.Shared/JavaScript/JavaScriptFreeTextSpellingHighlightFinder.cs

 		}
 
 		private bool WordIsIgnored(string word) {
-			return JavaScriptUtil.IsKeyword(word)
+			return CStyleFreeTextParser.LooksLikeCodeWord(word)
+				|| JavaScriptUtil.IsKeyword(word)
 				|| _shellSpellCheckResources.IsIgnoredInsensitive(word)
 				|| _localIdentifierNames.Contains(word)
-				|| _declarationsCache.GetElementsByShortName(word).NotNullAndHasAny()
-				|| _localIdentifierNames.Contains(word + "Attribute")
-				|| _declarationsCache.GetElementsByShortName(word + "Attribute").NotNullAndHasAny()
-				|| CStyleFreeTextParser.LooksLikeCodeWord(word);
+				|| _declarationsCache.GetElementsByShortName(word).NotNullAndHasAny();
 		}
 
 		/// <summary>

File src/YouCantSpell.ReSharper.Shared/JavaScript/JavaScriptSpellCheckDaemonStageProcess.cs

 using JetBrains.ReSharper.Psi.Naming.Interfaces;
 using JetBrains.ReSharper.Psi.Naming.Settings;
 using JetBrains.ReSharper.Psi.Tree;
-using JetBrains.Util;
 
 namespace YouCantSpell.ReSharper.JavaScript
 {
 	{
 
 		private const int MinWordSize = 2;
+		private const int MaxSuggestions = 10;
 
 		/// <summary>
 		/// Finds text that is only letters.
 		private readonly INamingPolicyProvider _namingPolicyProvider;
 		private readonly IPsiSourceFile _sourceFile;
 		private readonly IJavaScriptFile _javaScriptFile;
+		private readonly IDocument _document;
 
 		public JavaScriptSpellCheckDaemonStageProcess(IDaemonProcess process, IContextBoundSettingsStore settingsStore, IJavaScriptFile javaScriptFile)
 #if RSHARP6
 			_javaScriptFile = javaScriptFile;
 			_spellCheckResources = Shell.Instance.GetComponent<ShellSpellCheckResources>();
 			_sourceFile = process.SourceFile;
+			_document = _sourceFile.Document;
 			var psiServices = _sourceFile.PsiModule.GetPsiServices();
 			_namingManager = psiServices.Naming;
 			_namingPolicyProvider = _namingManager.Policy.GetPolicyProvider(JavaScriptLanguage.Instance, _sourceFile, settingsStore);
 
 		}
 
-		private IEnumerable<NamePart> ParseNameParts(string nameText) {
+		private readonly Dictionary<string, NamePart[]> _parseNamePartsCache = new Dictionary<string, NamePart[]>();
+		private readonly object _parseNamePartsCacheMutex = new object();
+		private NamePart[] ParseNameParts(string nameText) {
+			lock(_parseNamePartsCacheMutex) {
+				NamePart[] result;
+				if (!_parseNamePartsCache.TryGetValue(nameText, out result)) {
+					result = ParseNamePartsCore(nameText).ToArray();
+					_parseNamePartsCache.Add(nameText, result);
+				}
+				return result;
+			}
+		}
+
+		private List<NamePart> ParseNamePartsCore(string nameText) {
+			var nameParts = new List<NamePart>(0);
 			var parsedName = ParseName(nameText);
-			if(parsedName.InnerElements == null || parsedName.InnerElements.Count == 0)
-				yield break;
+			if (parsedName.InnerElements == null || parsedName.InnerElements.Count == 0)
+				return nameParts;
 
 			int identifierNamePartIndex = null != parsedName.NamePrefix ? parsedName.NamePrefix.Text.Length : 0;
 
 			foreach(var identifierNamePart in parsedName.InnerElements) {
-				if(!identifierNamePart.IsSeparator) {
-					yield return new NamePart { Text = identifierNamePart.Text, IdentifierOffset = identifierNamePartIndex };
-				}
+				if(!identifierNamePart.IsSeparator)
+					nameParts.Add(new NamePart { Text = identifierNamePart.Text, IdentifierOffset = identifierNamePartIndex });
+				
 				identifierNamePartIndex += identifierNamePart.Text.Length;
 			}
+
+			return nameParts;
 		}
 
 		public ShellSpellCheckResources SpellCheckResources {
 			get { return SpellCheckResources.Primary; }
 		}
 
+		private bool IsIgnored(string text, HashSet<string> ignored) {
+			return String.IsNullOrEmpty(text)
+				|| text.Length <= MinWordSize
+				|| ignored.Contains(text)
+				|| JavaScriptUtil.IsKeyword(text)
+				|| SpellCheckResources.IsIgnoredInsensitive(text);
+		}  
+
 		private IEnumerable<HighlightingInfo> FindHighlightings(IIdentifier identifier) {
+			var results = new List<HighlightingInfo>(0);
+
+			var declared = ReSharperUtil.GetDeclaredElement(identifier);
+			if(null == declared)
+				return results;
 
 			var validRange = FindTrueDocumentRange(identifier.GetTreeTextRange());
 			if (!validRange.HasValue)
-				yield break;
+				return results;
+
 			var validPartRange = validRange.Value;
 
-			var declared = ReSharperUtil.GetDeclaredElement(identifier);
-			if(null == declared)
-				yield break;
+			var localIgnoredWords = new HashSet<string>(
+				ParseSuperWords(declared as ITypeElement),
+				StringComparer.InvariantCultureIgnoreCase);
 
-			var localIgnoredWords = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
+			if (IsIgnored(identifier.Name, localIgnoredWords))
+				return results;
 
-			localIgnoredWords.AddRange(ParseSuperWords(declared as ITypeElement)); // TODO: does this even work with JS?
-
-			var namingPolicy = _namingPolicyProvider.GetPolicy(declared);
 			var parsedNameParts = ParseNameParts(identifier.Name).ToList();
 			var formatter = new JavaScriptSpellingSuggestionFormatter(
-				identifier,
-				namingPolicy,
-				_namingManager,
+				identifier.Name,
+				_namingPolicyProvider.GetPolicy(declared).NamingRule,
+				_namingManager.Parsing,
 				_sourceFile.PrimaryPsiLanguage,
 				_namingPolicyProvider,
 				parsedNameParts.Count
 					.Cast<Match>()
 					.SingleOrDefault(x => x.Success);
 
-				if(
-					null == wordPart
-					|| String.IsNullOrEmpty(wordPart.Value)
-					|| wordPart.Length <= MinWordSize
-					|| localIgnoredWords.Contains(wordPart.Value)
-					|| JavaScriptUtil.IsKeyword(wordPart.Value)
-					|| SpellCheckResources.IsIgnoredInsensitive(wordPart.Value)
-					|| PrimarySpellChecker.Check(wordPart.Value)
-				) continue;
+				if(null == wordPart || IsIgnored(wordPart.Value, localIgnoredWords))
+					continue;
 
-				var suggestions = PrimarySpellChecker
-					.GetRecommendations(wordPart.Value)
-					.Select(x => formatter.FormatSuggestion(x, i))
-					.Distinct()
-					.Take(10)
-					.ToArray();
-
-				if(suggestions.Contains(wordPart.Value))
-					continue; // its probably OK
+				if (PrimarySpellChecker.Check(wordPart.Value))
+					continue;
 
 				var identifierLeftTrim = namePart.IdentifierOffset + wordPart.Index;
 				var localValidPartRange = (identifierLeftTrim > 0)
 
 				localValidPartRange = localValidPartRange.SetEndTo(localValidPartRange.TextRange.StartOffset + wordPart.Value.Length);
 
-				var highlight = new JavaScriptSpellingErrorHighlighting(identifier, localValidPartRange, wordPart.Value, word => suggestions);
-				yield return new HighlightingInfo(localValidPartRange, highlight);
+				int wordPosition = i;
+				var highlight = new JavaScriptSpellingErrorHighlighting(
+					identifier,
+					localValidPartRange,
+					wordPart.Value,
+					word => PrimarySpellChecker
+						.GetRecommendations(word)
+						.Select(x => formatter.FormatSuggestion(x, wordPosition))
+						.Where(x => word != x)
+						.Distinct()
+						.Take(MaxSuggestions)
+						.ToArray()
+				);
+				results.Add(new HighlightingInfo(localValidPartRange, highlight));
 
 			}
-
-		}
-
-		private IDocument Document
-		{
-			get { return _sourceFile.Document; }
+			return results;
 		}
 
 		private IEnumerable<HighlightingInfo> FindHighlightings(IComment comment, HashSet<string> ignoredIdentifiers, IDeclarationsCache declarationsCache) {
 				return Enumerable.Empty<HighlightingInfo>();
 			var documentRange = validRange.Value;
 
-			return new JavaScriptFreeTextSpellingHighlightFinder(SpellCheckResources, Document, ignoredIdentifiers, declarationsCache)
+			return new JavaScriptFreeTextSpellingHighlightFinder(SpellCheckResources, _document, ignoredIdentifiers, declarationsCache)
 				.FindXmlTextHighlightings(comment, fullText, documentRange);
 		}
 
 			if(coreMatch.Groups[1].Index > 0)
 				textRange = textRange.SetStartTo(textRange.TextRange.StartOffset + coreMatch.Groups[1].Index);
 
-			return new JavaScriptFreeTextSpellingHighlightFinder(SpellCheckResources, Document, localIdentifierNames, declarationsCache)
+			return new JavaScriptFreeTextSpellingHighlightFinder(SpellCheckResources, _document, localIdentifierNames, declarationsCache)
 				.FindXmlTextHighlightings(node, coreMatch.Groups[1].Value, textRange);
 		}
 
 		private DocumentRange? FindTrueDocumentRange(TreeTextRange range) {
 			var validPartRanges = GetPsiFile().GetIntersectingRanges(range)
-					.Where(x => x.Document == Document)
+					.Where(x => x.Document == _document)
 					.ToList();
 			if (validPartRanges.Count != 1)
 				return null;

File src/YouCantSpell.ReSharper.Shared/JavaScript/JavaScriptSpellingSuggestionFormatter.cs

 using JetBrains.ReSharper.Psi.Naming.Interfaces;
 using JetBrains.ReSharper.Psi.Naming.Settings;
 using JetBrains.ReSharper.Psi.Tree;
+using YouCantSpell.Utility;
 
 namespace YouCantSpell.ReSharper.JavaScript
 {
 	public class JavaScriptSpellingSuggestionFormatter
 	{
 
-		// TODO: why does this regex have an '_' and why is it not named 'Suggestion Word Part Parser' or something similar?
-		protected static readonly Regex IdentifierRecombineRegex = new Regex(@"[^\s_-]+", RegexOptions.Compiled);
-
+		
 		/// <summary>
 		/// Force the casing of the first character in a string to the desired case.
 		/// </summary>
 			}
 		}
 
-		private readonly NamingPolicy _namingPolicy;
-		private readonly NamingManager _namingManager;
+		private readonly NamingRule _namingRule;
+		private readonly NameParser _nameParser;
 		private readonly PsiLanguageType _psiLanguageType;
 		private readonly INamingPolicyProvider _namingPolicyProvider;
 		private readonly int _wordCount;
 		private readonly TextCaseClassification _textClassification;
 
 		public JavaScriptSpellingSuggestionFormatter(
-			IIdentifier identifier,
-			NamingPolicy namingPolicy,
-			NamingManager namingManager,
+			string identifierName,
+			NamingRule namingRule,
+			NameParser nameParser,
 			PsiLanguageType psiLanguageType,
 			INamingPolicyProvider namingPolicyProvider,
 			int wordCount
 		) {
-			if(null == identifier)
-				throw new ArgumentNullException("identifier");
+			if(String.IsNullOrEmpty(identifierName))
+				throw new ArgumentNullException("identifierName");
+			if(null == namingRule)
+				throw new ArgumentNullException("namingRule");
+			if(null == nameParser)
+				throw new ArgumentNullException("nameParser");
 
-			_namingPolicy = namingPolicy;
-			_namingManager = namingManager;
+			_namingRule = namingRule;
+			_nameParser = nameParser;
 			_psiLanguageType = psiLanguageType;
 			_namingPolicyProvider = namingPolicyProvider;
 			_wordCount = wordCount;
-			_textClassification = Utility.StringUtil.ClassifyCharCase(identifier.Name);
+			_textClassification = StringUtil.ClassifyCharCase(identifierName);
 		}
 
 		/// <summary>
 		/// <returns>The suggestion formatted in a way so as to respect the configured naming conventions.</returns>
 		public string FormatSuggestion(string suggestion, int position) {
 			// Get the word parts of the suggestion.
-			var matches = IdentifierRecombineRegex.Matches(suggestion).Cast<Match>().Select(x => x.Value).ToArray();
+			var matches = StringUtil.LetterParserRegex.Matches(suggestion).Cast<Match>().Select(x => x.Value).ToArray();
 			if(matches.Length == 0)
 				return suggestion;
 
 			// Use resharper to reformat the word parts
-			var newSuggestion = _namingManager.Parsing.RenderNameSafe(
+			var newSuggestion = _nameParser.RenderNameSafe(
 				NameRoot.FromWords(Emphasis.Unknown, false, matches),
-				_namingPolicy.NamingRule,
+				_namingRule,
 				_psiLanguageType,
 				_namingPolicyProvider);
 
-			var firstWord = 0 == position; // the first word within an identifier often has special casing that differs from the other words: firstSecondThird
-			var literalIsOk = firstWord && _wordCount == 1; // literals (@object) are only OK if there is one word in the identifier
-			// TODO: if there is 1 word in the identifier then how can we not be the first word?
+			var literalIsOk = _wordCount == 1; // literals (@object) are only OK if there is one word in the identifier
 
 			// after rendering the suggestion as an identifier name we need to parse it again to remove some stuff
 			// just in case anything funny like a prefix or @ was added we need to get rid of that (unless @ is OK)
-			var reparsedNamed = _namingManager.Parsing.Parse(newSuggestion, NamingRule.Default, _namingPolicyProvider);
+			var reparsedNamed = _nameParser.Parse(newSuggestion, NamingRule.Default, _namingPolicyProvider);
 			if(reparsedNamed.NamePrefix.Text.Length > 0 && (!literalIsOk || reparsedNamed.NamePrefix.Text != "@")) {
 				// we need to pull the prefix off except for one special situation, with literals, if that is a prefix
 				newSuggestion = newSuggestion.Substring(reparsedNamed.NamePrefix.Text.Length);
 				newSuggestion = newSuggestion.Substring(1); // if the @ prefix is not OK we need to get rid of that
 
 			// Preserve the ugly all upper-case variables by forcing the new identifier part to uppercase if the identifier was uppercase to begin with
-			if(_textClassification == TextCaseClassification.Upper && _namingPolicy.NamingRule.NamingStyleKind != NamingStyleKinds.AA_BB)
+			if(_textClassification == TextCaseClassification.Upper && _namingRule.NamingStyleKind != NamingStyleKinds.AA_BB)
 				return newSuggestion.ToUpper();
 
 			// Don't know what to do if the suggestion was made to be blank
 			if(String.IsNullOrEmpty(newSuggestion))
 				return newSuggestion;
 
-			if(!firstWord) {
+			// the first word within an identifier often has special casing that differs from the other words: firstSecondThird
+			if (0 != position) {
 				// Here we may need to correct the first letter if this is not the first word as the naming provider assumes the first word.
 				// The R# methods assume the words I am giving it are the entire identifier name so the first letter may not be correct for
 				// a suggestion derived from the 2nd word part within an identifier, we will need to adjust that.
 				newSuggestion = ForceFirstCharCase(
 					newSuggestion,
-					SecondWordFirstLetterClassification(_namingPolicy.NamingRule.NamingStyleKind)
+					SecondWordFirstLetterClassification(_namingRule.NamingStyleKind)
 				);
 			}
 

File src/YouCantSpell.ReSharper.Shared/SpellingErrorHighlightingBase.cs

 using YouCantSpell.ReSharper;
 
 // this defines the common category information for the spelling highlighting, for example when finding problems with the solution
-[assembly: RegisterConfigurableSeverity(SpellingErrorHighlightingBase.SeverityId,
+[assembly: RegisterConfigurableHighlightingsGroupAttribute("Spelling", "Spelling")]
+[assembly: RegisterConfigurableSeverity(
+	SpellingErrorHighlightingBase.SeverityId,
 	null,
 	"Spelling",
-	"Spelling mistake",
+	"Spelling mistakes",
 	"You can't spell",
 	Severity.HINT,
-	false)]
+	false
+)]
 
 namespace YouCantSpell.ReSharper
 {

File test/data/Simple/Highlight/Delepsim.js.gold

     }
 } ();
 ---------------------------------------------------------
-(0): ReSharper Hint: Spelling error: "spellled"
-(1): ReSharper Hint: Spelling error: "goood"
-(2): ReSharper Hint: Spelling error: "mispellled"
-(3): ReSharper Hint: Spelling error: "wrongspelling"
-(4): ReSharper Hint: Spelling error: "notgoodspelling"
-(5): ReSharper Hint: Spelling error: "spelledbad"
-(6): ReSharper Hint: Spelling error: "badparam"
-(7): ReSharper Hint: Spelling error: "wrrong"
+(0): ReSharper Hint: Spelling error: spellled
+(1): ReSharper Hint: Spelling error: goood
+(2): ReSharper Hint: Spelling error: mispellled
+(3): ReSharper Hint: Spelling error: wrongspelling
+(4): ReSharper Hint: Spelling error: notgoodspelling
+(5): ReSharper Hint: Spelling error: spelledbad
+(6): ReSharper Hint: Spelling error: badparam
+(7): ReSharper Hint: Spelling error: wrrong

File test/data/Simple/Highlight/Keyword.cs.gold

 
 
 ---------------------------------------------------------
-(0): ReSharper Hint: Spelling error: "justtomakesureitispayingattention"
+(0): ReSharper Hint: Spelling error: justtomakesureitispayingattention

File test/data/Simple/Highlight/KnownIdentifiers.cs.gold

 
 
 ---------------------------------------------------------
-(0): ReSharper Hint: Spelling error: "mispellled"
-(1): ReSharper Hint: Spelling error: "wrrong"
-(2): ReSharper Hint: Spelling error: "spellled"
+(0): ReSharper Hint: Spelling error: mispellled
+(1): ReSharper Hint: Spelling error: wrrong
+(2): ReSharper Hint: Spelling error: spellled

File test/data/Simple/Highlight/Mispeled.cs.gold

 }
 
 ---------------------------------------------------------
-(0): ReSharper Hint: Spelling error: "Mispeled"
-(1): ReSharper Hint: Spelling error: "mispeled"
-(2): ReSharper Hint: Spelling error: "Mispeled"
-(3): ReSharper Hint: Spelling error: "Mispeled"
-(4): ReSharper Hint: Spelling error: "args"
-(5): ReSharper Hint: Spelling error: "mispeled"
-(6): ReSharper Hint: Spelling error: "dookie"
+(0): ReSharper Hint: Spelling error: Mispeled
+(1): ReSharper Hint: Spelling error: mispeled
+(2): ReSharper Hint: Spelling error: Mispeled
+(3): ReSharper Hint: Spelling error: Mispeled
+(4): ReSharper Hint: Spelling error: args
+(5): ReSharper Hint: Spelling error: mispeled
+(6): ReSharper Hint: Spelling error: dookie

File test/data/Simple/Highlight/SkipInherrited.cs.gold

 {
 	public Class() {
 
-		var |mispellled|(0) = new Mispellled();
+		var mispellled = new Mispellled();
 
 	}
 }
 	}
 }
 
-public interface I|Mispellled|(1)
+public interface I|Mispellled|(0)
 {
-	int |Joinedword|(2)();
+	int |Joinedword|(1)();
 }
 
 ---------------------------------------------------------
-(0): ReSharper Hint: Spelling error: "mispellled"
-(1): ReSharper Hint: Spelling error: "Mispellled"
-(2): ReSharper Hint: Spelling error: "Joinedword"
+(0): ReSharper Hint: Spelling error: Mispellled
+(1): ReSharper Hint: Spelling error: Joinedword

File test/data/Simple/Highlight/StringLiteral.cs.gold

 
 
 ---------------------------------------------------------
-(0): ReSharper Hint: Spelling error: "Fnid"
-(1): ReSharper Hint: Spelling error: "prolbems"
-(2): ReSharper Hint: Spelling error: "wiht"
-(3): ReSharper Hint: Spelling error: "thsi"
-(4): ReSharper Hint: Spelling error: "misppellling"
-(5): ReSharper Hint: Spelling error: "onn"
-(6): ReSharper Hint: Spelling error: "mulltiple"
-(7): ReSharper Hint: Spelling error: "liines"
-(8): ReSharper Hint: Spelling error: "onne"
-(9): ReSharper Hint: Spelling error: "twwo"
-(10): ReSharper Hint: Spelling error: "threee"
-(11): ReSharper Hint: Spelling error: "fouur"
-(12): ReSharper Hint: Spelling error: "onne"
-(13): ReSharper Hint: Spelling error: "twwo"
-(14): ReSharper Hint: Spelling error: "threee"
-(15): ReSharper Hint: Spelling error: "fouur"
+(0): ReSharper Hint: Spelling error: Fnid
+(1): ReSharper Hint: Spelling error: prolbems
+(2): ReSharper Hint: Spelling error: wiht
+(3): ReSharper Hint: Spelling error: thsi
+(4): ReSharper Hint: Spelling error: misppellling
+(5): ReSharper Hint: Spelling error: onn
+(6): ReSharper Hint: Spelling error: mulltiple
+(7): ReSharper Hint: Spelling error: liines
+(8): ReSharper Hint: Spelling error: onne
+(9): ReSharper Hint: Spelling error: twwo
+(10): ReSharper Hint: Spelling error: threee
+(11): ReSharper Hint: Spelling error: fouur
+(12): ReSharper Hint: Spelling error: onne
+(13): ReSharper Hint: Spelling error: twwo
+(14): ReSharper Hint: Spelling error: threee
+(15): ReSharper Hint: Spelling error: fouur

File test/data/Simple/QuickFix/Availability/v61/Delepsim.js.gold

     }
 } ();
 ------------------------------------------------
-0: Spelling error: "spellled"
+0: Spelling error: spellled
 QUICKFIXES:
-Replace with "spelled"
-Replace with "spell led"
-Replace with "spell-led"
-Replace with "speller"
-Replace with "spanielled"
-Replace with "speedwell"
-Replace with "expelled"
-Replace with "spelldown"
-Replace with "splatted"
+Replace with: spelled
+Replace with: spell led
+Replace with: spell-led
+Replace with: spellable
+Replace with: speller
+Replace with: speedwell
+Replace with: pelleted
+Replace with: spelldown
+Replace with: spellbind
 Add "spellled" to dictionary
 Ignore spelling for "spellled"
-1: Spelling error: "goood"
+1: Spelling error: goood
 QUICKFIXES:
-Replace with "good"
-Replace with "Good"
-Replace with "godhood"
-Replace with "goo"
-Replace with "God"
-Replace with "Gouda"
-Replace with "gourd"
+Replace with: good
+Replace with: Good
+Replace with: godhood
+Replace with: goosed
+Replace with: goo
+Replace with: Gouda
+Replace with: gourd
 Add "goood" to dictionary
 Ignore spelling for "goood"
-2: Spelling error: "mispellled"
+2: Spelling error: mispellled
 QUICKFIXES:
-Replace with "Misspelled"
-Replace with "Dispelled"
-Replace with "Misspell"
-Replace with "Impelled"
-Replace with "Misapplier"
-Replace with "Misplacement"
+Replace with: Misspelled
+Replace with: Dispelled
+Replace with: Misspell
+Replace with: Respelled
+Replace with: Misplace
+Replace with: Misplay
 Add "mispellled" to dictionary
 Ignore spelling for "mispellled"
-3: Spelling error: "wrongspelling"
+3: Spelling error: wrongspelling
 QUICKFIXES:
-Replace with "WrongSpelling"
-Replace with "Propelling"
-Replace with "Misspelling"
-Replace with "Dispelling"
-Replace with "Counsellings"
-Replace with "Wrongfulness"
-Replace with "Nonexplosive"
+Replace with: WrongSpelling
+Replace with: Respelling
+Replace with: Propelling
+Replace with: Misspelling
+Replace with: Dispelling
+Replace with: Unexplainable
+Replace with: Unexplained
 Add "wrongspelling" to dictionary
 Ignore spelling for "wrongspelling"
-4: Spelling error: "notgoodspelling"
+4: Spelling error: notgoodspelling
 QUICKFIXES:
-Replace with "dispelling"
-Replace with "misspelling"
-Replace with "propelling"
-Replace with "spelling"
-Replace with "nondisciplinary"
-Replace with "interdisciplinary"
+Replace with: nonspecializing
+Replace with: dispelling
+Replace with: misspelling
+Replace with: propelling
+Replace with: nondisciplinary
+Replace with: interdisciplinary
 Add "notgoodspelling" to dictionary
 Ignore spelling for "notgoodspelling"
-5: Spelling error: "spelledbad"
+5: Spelling error: spelledbad
 QUICKFIXES:
-Replace with "SpelledBad"
-Replace with "Spelled"
-Replace with "Spanielled"
-Replace with "Spellbind"
-Replace with "Speedwell"
-Replace with "Splittable"
-Replace with "Spellbound"
+Replace with: SpelledBad
+Replace with: Spellable
+Replace with: Spellbind
+Replace with: Speedwell
+Replace with: Spreadeagled
+Replace with: Splittable
+Replace with: Spellbound
 Add "spelledbad" to dictionary
 Ignore spelling for "spelledbad"
-6: Spelling error: "badparam"
+6: Spelling error: badparam
 QUICKFIXES:
-Replace with "paramaribo"
-Replace with "bartram"
-Replace with "baryram"
-Replace with "paradigm"
-Replace with "taproom"
-Replace with "bootprints"
+Replace with: paramaribo
+Replace with: paradigm
+Replace with: barbara
+Replace with: parader
+Replace with: taproom
+Replace with: deprogram
 Add "badparam" to dictionary
 Ignore spelling for "badparam"
-7: Spelling error: "wrrong"
+7: Spelling error: wrrong
 QUICKFIXES:
-Replace with "wrong"
-Replace with "prong"
-Replace with "wrung"
-Replace with "wring"
-Replace with "wrangle"
-Replace with "strong"
+Replace with: wrong
+Replace with: prong
+Replace with: rowing
+Replace with: wrung
+Replace with: wring
+Replace with: wrangle
+Replace with: throng
 Add "wrrong" to dictionary
 Ignore spelling for "wrrong"

File test/data/Simple/QuickFix/Availability/v61/Keyword.cs.gold

 
 
 ------------------------------------------------
-0: Spelling error: "justtomakesureitispayingattention"
+0: Spelling error: justtomakesureitispayingattention
 QUICKFIXES:
+Replace with: inattention
 Add "justtomakesureitispayingattention" to dictionary
 Ignore spelling for "justtomakesureitispayingattention"

File test/data/Simple/QuickFix/Availability/v61/KnownIdentifiers.cs.gold

 
 
 ------------------------------------------------
-0: Spelling error: "mispellled"
+0: Spelling error: mispellled
 QUICKFIXES:
-Replace with "Misspelled"
-Replace with "Dispelled"
-Replace with "Misspell"
-Replace with "Impelled"
-Replace with "Misapplier"
-Replace with "Misplacement"
+Replace with: Misspelled
+Replace with: Dispelled
+Replace with: Misspell
+Replace with: Respelled
+Replace with: Misplace
+Replace with: Misplay
 Add "mispellled" to dictionary
 Ignore spelling for "mispellled"
-1: Spelling error: "wrrong"
+1: Spelling error: wrrong
 QUICKFIXES:
-Replace with "wrong"
-Replace with "prong"
-Replace with "wrung"
-Replace with "wring"
-Replace with "wrangle"
-Replace with "strong"
+Replace with: wrong
+Replace with: prong
+Replace with: rowing
+Replace with: wrung
+Replace with: wring
+Replace with: wrangle
+Replace with: throng
 Add "wrrong" to dictionary
 Ignore spelling for "wrrong"
-2: Spelling error: "spellled"
+2: Spelling error: spellled
 QUICKFIXES:
-Replace with "spelled"
-Replace with "spell led"
-Replace with "spell-led"
-Replace with "speller"
-Replace with "spanielled"
-Replace with "speedwell"
-Replace with "expelled"
-Replace with "spelldown"
-Replace with "splatted"
+Replace with: spelled
+Replace with: spell led
+Replace with: spell-led
+Replace with: spellable
+Replace with: speller
+Replace with: speedwell
+Replace with: pelleted
+Replace with: spelldown
+Replace with: spellbind
 Add "spellled" to dictionary
 Ignore spelling for "spellled"

File test/data/Simple/QuickFix/Availability/v61/Mispeled.cs.gold

 }
 
 ------------------------------------------------
-0: Spelling error: "Mispeled"
+0: Spelling error: Mispeled
 QUICKFIXES:
-Replace with "Misspelled"
-Replace with "Dispelled"
-Replace with "Misspell"
-Replace with "Mislabeled"
-Replace with "Misplace"
-Replace with "Misapplier"
+Replace with: Misspelled
+Replace with: Dispelled
+Replace with: Misspell
+Replace with: Mislabeled
+Replace with: Misplace
+Replace with: Misapply
 Add "Mispeled" to dictionary
 Ignore spelling for "Mispeled"
-1: Spelling error: "mispeled"
+1: Spelling error: mispeled
 QUICKFIXES:
-Replace with "Misspelled"
-Replace with "Dispelled"
-Replace with "Misspell"
-Replace with "Mislabeled"
-Replace with "Misplace"
-Replace with "Misapplier"
+Replace with: Misspelled
+Replace with: Dispelled
+Replace with: Misspell
+Replace with: Mislabeled
+Replace with: Misplace
+Replace with: Misapply
 Add "mispeled" to dictionary
 Ignore spelling for "mispeled"
-2: Spelling error: "Mispeled"
+2: Spelling error: Mispeled
 QUICKFIXES:
-Replace with "Misspelled"
-Replace with "Dispelled"
-Replace with "Misspell"
-Replace with "Mislabeled"
-Replace with "Misplace"
-Replace with "Misapplier"
+Replace with: Misspelled
+Replace with: Dispelled
+Replace with: Misspell
+Replace with: Mislabeled
+Replace with: Misplace
+Replace with: Misapply
 Add "Mispeled" to dictionary
 Ignore spelling for "Mispeled"
-3: Spelling error: "Mispeled"
+3: Spelling error: Mispeled
 QUICKFIXES:
-Replace with "Misspelled"
-Replace with "Dispelled"
-Replace with "Misspell"
-Replace with "Mislabeled"
-Replace with "Misplace"
-Replace with "Misapplier"
+Replace with: Misspelled
+Replace with: Dispelled
+Replace with: Misspell
+Replace with: Mislabeled
+Replace with: Misplace
+Replace with: Misapply
 Add "Mispeled" to dictionary
 Ignore spelling for "Mispeled"
-4: Spelling error: "args"
+4: Spelling error: args
 QUICKFIXES:
-Replace with "rags"
-Replace with "gars"
-Replace with "ares"
-Replace with "ergs"
-Replace with "arts"
-Replace with "arcs"
-Replace with "arms"
-Replace with "arks"
-Replace with "argos"
-Replace with "argus"
+Replace with: rags
+Replace with: gars
+Replace with: ares
+Replace with: ergs
+Replace with: arts
+Replace with: arcs
+Replace with: arms
+Replace with: arks
+Replace with: argus
+Replace with: argos
 Add "args" to dictionary
 Ignore spelling for "args"
-5: Spelling error: "mispeled"
+5: Spelling error: mispeled
 QUICKFIXES:
-Replace with "misspelled"
-Replace with "dispelled"
-Replace with "misspell"
-Replace with "mislabeled"
-Replace with "misplace"
-Replace with "misapplier"
+Replace with: misspelled
+Replace with: dispelled
+Replace with: misspell
+Replace with: mislabeled
+Replace with: misplace
+Replace with: misapply
 Add "mispeled" to dictionary
 Ignore spelling for "mispeled"
-6: Spelling error: "dookie"
+6: Spelling error: dookie
 QUICKFIXES:
-Replace with "rookie"
-Replace with "cookie"
-Replace with "bookie"
-Replace with "dodie"
-Replace with "dorie"
-Replace with "dogie"
-Replace with "dotage"
-Replace with "dickier"
+Replace with: nookie
+Replace with: rookie
+Replace with: cookie
+Replace with: bookie
+Replace with: kookie
+Replace with: dogie
+Replace with: dockside
+Replace with: docking
 Add "dookie" to dictionary
 Ignore spelling for "dookie"

File test/data/Simple/QuickFix/Availability/v61/SkipInherrited.cs.gold

 {
 	public Class() {
 
-		var |mispellled|(0) = new Mispellled();
+		var mispellled = new Mispellled();
 
 	}
 }
 	}
 }
 
-public interface I|Mispellled|(1)
+public interface I|Mispellled|(0)
 {
-	int |Joinedword|(2)();
+	int |Joinedword|(1)();
 }
 
 ------------------------------------------------
-0: Spelling error: "mispellled"
+0: Spelling error: Mispellled
 QUICKFIXES:
-Replace with "misspelled"
-Replace with "dispelled"
-Replace with "misspell"
-Replace with "impelled"
-Replace with "misapplier"
-Replace with "misplacement"
-Add "mispellled" to dictionary
-Ignore spelling for "mispellled"
-1: Spelling error: "Mispellled"
-QUICKFIXES:
-Replace with "Misspelled"
-Replace with "Dispelled"
-Replace with "Misspell"
-Replace with "Impelled"
-Replace with "Misapplier"
-Replace with "Misplacement"
+Replace with: Misspelled
+Replace with: Dispelled
+Replace with: Misspell
+Replace with: Respelled
+Replace with: Misplace
+Replace with: Misplay
 Add "Mispellled" to dictionary
 Ignore spelling for "Mispellled"
-2: Spelling error: "Joinedword"
+1: Spelling error: Joinedword
 QUICKFIXES:
-Replace with "JoinedWord"
-Replace with "Joined"
-Replace with "Wordiness"
-Replace with "Jointed"
-Replace with "Rejoinder"
-Replace with "Counterweight"
-Replace with "Groundwater"
+Replace with: JoinedWord
+Replace with: Conjoined
+Replace with: Jointed
+Replace with: Rejoinder
+Replace with: Countywide
+Replace with: Counterweight
 Add "Joinedword" to dictionary
 Ignore spelling for "Joinedword"

File test/data/Simple/QuickFix/Availability/v61/StringLiteral.cs.gold

 
 
 ------------------------------------------------
-0: Spelling error: "Fnid"
+0: Spelling error: Fnid
 QUICKFIXES:
-Replace with "Enid"
-Replace with "Find"
-Replace with "Ifni"
-Replace with "Fend"
-Replace with "Fond"
+Replace with: Enid
+Replace with: Find
+Replace with: Fend
+Replace with: Fond
 Add "Fnid" to dictionary
 Ignore spelling for "Fnid"
-1: Spelling error: "prolbems"
+1: Spelling error: prolbems
 QUICKFIXES:
-Replace with "problems"
-Replace with "problem"
-Replace with "prologize"
-Replace with "prolegomena"
+Replace with: problems
+Replace with: problem
+Replace with: proles
+Replace with: probes
+Replace with: prolapse
+Replace with: prologize
 Add "prolbems" to dictionary
 Ignore spelling for "prolbems"
-2: Spelling error: "wiht"
+2: Spelling error: wiht
 QUICKFIXES:
-Replace with "whit"
-Replace with "with"
-Replace with "wit"
-Replace with "wight"
-Replace with "wist"
-Replace with "wilt"
-Replace with "Witt"
-Replace with "Wait"
+Replace with: whit
+Replace with: with
+Replace with: wit
+Replace with: wight
+Replace with: wist
+Replace with: wilt
+Replace with: Witt
+Replace with: weight
 Add "wiht" to dictionary
 Ignore spelling for "wiht"
-3: Spelling error: "thsi"
+3: Spelling error: thsi
 QUICKFIXES:
-Replace with "this"
-Replace with "sixths"
-Replace with "thesis"
-Replace with "thighs"
-Replace with "saiths"
-Replace with "thus"
-Replace with "Thespis"
+Replace with: this
+Replace with: thesis
+Replace with: sixth
+Replace with: thus
+Replace with: Thurs
 Add "thsi" to dictionary
 Ignore spelling for "thsi"
-4: Spelling error: "misppellling"
+4: Spelling error: misppellling
 QUICKFIXES:
-Replace with "misspelling"
-Replace with "dispelling"
-Replace with "rappelling"
-Replace with "spanielling"
-Replace with "misplacement"
-Replace with "misapplier"
+Replace with: misspelling
+Replace with: dispelling
+Replace with: respelling
+Replace with: rappelling
+Replace with: misapplication
+Replace with: misplacement
 Add "misppellling" to dictionary
 Ignore spelling for "misppellling"
-5: Spelling error: "onn"
+5: Spelling error: onn
 QUICKFIXES:
-Replace with "non"
-Replace with "inn"
-Replace with "on"
-Replace with "conn"
-Replace with "Conn"
-Replace with "Donn"
-Replace with "Bonn"
-Replace with "one"
-Replace with "ons"
-Replace with "own"
-Replace with "Ann"
-Replace with "on n"
-Replace with "Ono"
-Replace with "ON"
-Replace with "Ont"
+Replace with: non
+Replace with: inn
+Replace with: on
+Replace with: Conn
+Replace with: Donn
+Replace with: Bonn
+Replace with: one
+Replace with: own
+Replace with: Ann
+Replace with: on n
+Replace with: Ono
+Replace with: ON
+Replace with: Ont
+Replace with: Onegin
 Add "onn" to dictionary
 Ignore spelling for "onn"
-6: Spelling error: "mulltiple"
+6: Spelling error: mulltiple
 QUICKFIXES:
-Replace with "multiple"
-Replace with "multipliable"
-Replace with "multiplier"
-Replace with "multiply"
-Replace with "multiphase"
-Replace with "multiplicity"
-Replace with "multiplicand"
+Replace with: multiple
+Replace with: multiplier
+Replace with: multiply
+Replace with: multiphase
+Replace with: multilevel
+Replace with: multiplicity
+Replace with: multiplicand
 Add "mulltiple" to dictionary
 Ignore spelling for "mulltiple"
-7: Spelling error: "liines"
+7: Spelling error: liines
 QUICKFIXES:
-Replace with "lines"
-Replace with "lineages"
-Replace with "linens"
-Replace with "sliminess"
-Replace with "lioness"
-Replace with "line's"
-Replace with "linseed"
+Replace with: lines
+Replace with: lineages
+Replace with: linens
+Replace with: liners
+Replace with: lioness
+Replace with: Linnaeus
+Replace with: linseed
 Add "liines" to dictionary
 Ignore spelling for "liines"
-8: Spelling error: "onne"
+8: Spelling error: onne
 QUICKFIXES:
-Replace with "none"
-Replace with "one"
-Replace with "tonne"
-Replace with "Donne"
-Replace with "once"
-Replace with "Anne"
-Replace with "Evonne"
-Replace with "Deonne"
-Replace with "Bonnee"
-Replace with "Dionne"
-Replace with "annex"
-Replace with "inner"
+Replace with: none
+Replace with: one
+Replace with: tonne
+Replace with: Donne
+Replace with: once
+Replace with: Anne
+Replace with: Dionne
+Replace with: Yvonne
+Replace with: Conner
+Replace with: Bonner
+Replace with: onion
+Replace with: Onion
 Add "onne" to dictionary
 Ignore spelling for "onne"
-9: Spelling error: "twwo"
+9: Spelling error: twwo
 QUICKFIXES:
-Replace with "two"
-Replace with "wot"
-Replace with "twas"
-Replace with "twee"
+Replace with: two
+Replace with: wot
+Replace with: twas
+Replace with: twat
 Add "twwo" to dictionary
 Ignore spelling for "twwo"
-10: Spelling error: "threee"
+10: Spelling error: threee
 QUICKFIXES:
-Replace with "three"
-Replace with "threes"
-Replace with "three e"
-Replace with "thresher"
-Replace with "thresh"
-Replace with "threat"
-Replace with "threader"
-Replace with "Therese"
-Replace with "thrower"
+Replace with: three
+Replace with: threes
+Replace with: three e
+Replace with: thresh
+Replace with: threat
+Replace with: threader
+Replace with: threw
+Replace with: thread
+Replace with: thrice
 Add "threee" to dictionary
 Ignore spelling for "threee"
-11: Spelling error: "fouur"
+11: Spelling error: fouur
 QUICKFIXES:
-Replace with "four"
-Replace with "Fourier"
-Replace with "Fourth"
-Replace with "flour"
-Replace with "formal"
-Replace with "format"
+Replace with: four
+Replace with: Fourth
+Replace with: Fourier
+Replace with: flour
+Replace with: force
+Replace with: foray
 Add "fouur" to dictionary
 Ignore spelling for "fouur"
-12: Spelling error: "onne"
+12: Spelling error: onne
 QUICKFIXES:
-Replace with "none"
-Replace with "one"
-Replace with "tonne"
-Replace with "Donne"
-Replace with "once"
-Replace with "Anne"
-Replace with "Evonne"
-Replace with "Deonne"
-Replace with "Bonnee"
-Replace with "Dionne"
-Replace with "annex"
-Replace with "inner"
+Replace with: none
+Replace with: one
+Replace with: tonne
+Replace with: Donne
+Replace with: once
+Replace with: Anne
+Replace with: Dionne
+Replace with: Yvonne
+Replace with: Conner
+Replace with: Bonner
+Replace with: onion
+Replace with: Onion
 Add "onne" to dictionary
 Ignore spelling for "onne"
-13: Spelling error: "twwo"
+13: Spelling error: twwo
 QUICKFIXES:
-Replace with "two"
-Replace with "wot"
-Replace with "twas"
-Replace with "twee"
+Replace with: two
+Replace with: wot
+Replace with: twas
+Replace with: twat
 Add "twwo" to dictionary
 Ignore spelling for "twwo"
-14: Spelling error: "threee"
+14: Spelling error: threee
 QUICKFIXES:
-Replace with "three"
-Replace with "threes"
-Replace with "three e"
-Replace with "thresher"
-Replace with "thresh"
-Replace with "threat"
-Replace with "threader"
-Replace with "Therese"
-Replace with "thrower"
+Replace with: three
+Replace with: threes
+Replace with: three e
+Replace with: thresh
+Replace with: threat
+Replace with: threader
+Replace with: threw
+Replace with: thread
+Replace with: thrice
 Add "threee" to dictionary
 Ignore spelling for "threee"
-15: Spelling error: "fouur"
+15: Spelling error: fouur
 QUICKFIXES:
-Replace with "four"
-Replace with "Fourier"
-Replace with "Fourth"
-Replace with "flour"
-Replace with "formal"
-Replace with "format"
+Replace with: four
+Replace with: Fourth
+Replace with: Fourier
+Replace with: flour
+Replace with: force
+Replace with: foray
 Add "fouur" to dictionary
 Ignore spelling for "fouur"

File test/data/Simple/QuickFix/Availability/v70/Delepsim.js.gold

     }
 } ();
 ------------------------------------------------
-0: Spelling error: "spellled"
+0: Spelling error: spellled
 QUICKFIXES:
 Spelling Fixes
---Replace with "spelled"
---Replace with "spell led"
---Replace with "spell-led"
---Replace with "speller"
---Replace with "spanielled"
---Replace with "speedwell"
---Replace with "expelled"
---Replace with "spelldown"
---Replace with "splatted"
+--Replace with: spelled
+--Replace with: spell led
+--Replace with: spell-led
+--Replace with: spellable
+--Replace with: speller
+--Replace with: speedwell
+--Replace with: pelleted
+--Replace with: spelldown
+--Replace with: spellbind
 --Add "spellled" to dictionary
 --Ignore spelling for "spellled"
-1: Spelling error: "goood"
+1: Spelling error: goood
 QUICKFIXES:
 Spelling Fixes
---Replace with "good"
---Replace with "Good"
---Replace with "godhood"
---Replace with "goo"
---Replace with "God"
---Replace with "Gouda"
---Replace with "gourd"
+--Replace with: good
+--Replace with: Good
+--Replace with: godhood
+--Replace with: goosed
+--Replace with: goo
+--Replace with: Gouda
+--Replace with: gourd
 --Add "goood" to dictionary
 --Ignore spelling for "goood"
-2: Spelling error: "mispellled"
+2: Spelling error: mispellled
 QUICKFIXES:
 Spelling Fixes
---Replace with "Misspelled"
---Replace with "Dispelled"
---Replace with "Misspell"
---Replace with "Impelled"
---Replace with "Misapplier"
---Replace with "Misplacement"
+--Replace with: Misspelled
+--Replace with: Dispelled
+--Replace with: Misspell
+--Replace with: Respelled
+--Replace with: Misplace
+--Replace with: Misplay
 --Add "mispellled" to dictionary
 --Ignore spelling for "mispellled"
-3: Spelling error: "wrongspelling"
+3: Spelling error: wrongspelling
 QUICKFIXES:
 Spelling Fixes
---Replace with "WrongSpelling"
---Replace with "Propelling"
---Replace with "Misspelling"
---Replace with "Dispelling"
---Replace with "Counsellings"
---Replace with "Wrongfulness"
---Replace with "Nonexplosive"
+--Replace with: WrongSpelling
+--Replace with: Respelling
+--Replace with: Propelling
+--Replace with: Misspelling
+--Replace with: Dispelling
+--Replace with: Unexplainable
+--Replace with: Unexplained
 --Add "wrongspelling" to dictionary
 --Ignore spelling for "wrongspelling"
-4: Spelling error: "notgoodspelling"
+4: Spelling error: notgoodspelling
 QUICKFIXES:
 Spelling Fixes
---Replace with "dispelling"
---Replace with "misspelling"
---Replace with "propelling"
---Replace with "spelling"
---Replace with "nondisciplinary"
---Replace with "interdisciplinary"
+--Replace with: nonspecializing
+--Replace with: dispelling
+--Replace with: misspelling
+--Replace with: propelling
+--Replace with: nondisciplinary
+--Replace with: interdisciplinary
 --Add "notgoodspelling" to dictionary
 --Ignore spelling for "notgoodspelling"
-5: Spelling error: "spelledbad"
+5: Spelling error: spelledbad
 QUICKFIXES:
 Spelling Fixes
---Replace with "SpelledBad"
---Replace with "Spelled"
---Replace with "Spanielled"
---Replace with "Spellbind"
---Replace with "Speedwell"
---Replace with "Splittable"
---Replace with "Spellbound"
+--Replace with: SpelledBad
+--Replace with: Spellable
+--Replace with: Spellbind
+--Replace with: Speedwell
+--Replace with: Spreadeagled
+--Replace with: Splittable
+--Replace with: Spellbound
 --Add "spelledbad" to dictionary
 --Ignore spelling for "spelledbad"
-6: Spelling error: "badparam"
+6: Spelling error: badparam
 QUICKFIXES:
 Spelling Fixes
---Replace with "paramaribo"
---Replace with "bartram"
---Replace with "baryram"
---Replace with "paradigm"
---Replace with "taproom"
---Replace with "bootprints"
+--Replace with: paramaribo
+--Replace with: paradigm
+--Replace with: barbara
+--Replace with: parader
+--Replace with: taproom
+--Replace with: deprogram
 --Add "badparam" to dictionary
 --Ignore spelling for "badparam"
-7: Spelling error: "wrrong"
+7: Spelling error: wrrong
 QUICKFIXES:
 Spelling Fixes
---Replace with "wrong"
---Replace with "prong"
---Replace with "wrung"
---Replace with "wring"
---Replace with "wrangle"
---Replace with "strong"
+--Replace with: wrong
+--Replace with: prong
+--Replace with: rowing
+--Replace with: wrung
+--Replace with: wring
+--Replace with: wrangle
+--Replace with: throng
 --Add "wrrong" to dictionary
 --Ignore spelling for "wrrong"

File test/data/Simple/QuickFix/Availability/v70/Keyword.cs.gold

 
 
 ------------------------------------------------
-0: Spelling error: "justtomakesureitispayingattention"
+0: Spelling error: justtomakesureitispayingattention
 QUICKFIXES:
 Spelling Fixes
+--Replace with: inattention
 --Add "justtomakesureitispayingattention" to dictionary
 --Ignore spelling for "justtomakesureitispayingattention"

File test/data/Simple/QuickFix/Availability/v70/KnownIdentifiers.cs.gold

 
 
 ------------------------------------------------
-0: Spelling error: "mispellled"
+0: Spelling error: mispellled
 QUICKFIXES:
 Spelling Fixes
---Replace with "Misspelled"
---Replace with "Dispelled"
---Replace with "Misspell"
---Replace with "Impelled"
---Replace with "Misapplier"
---Replace with "Misplacement"
+--Replace with: Misspelled
+--Replace with: Dispelled
+--Replace with: Misspell
+--Replace with: Respelled
+--Replace with: Misplace
+--Replace with: Misplay
 --Add "mispellled" to dictionary
 --Ignore spelling for "mispellled"
-1: Spelling error: "wrrong"
+1: Spelling error: wrrong
 QUICKFIXES:
 Spelling Fixes
---Replace with "wrong"
---Replace with "prong"
---Replace with "wrung"
---Replace with "wring"
---Replace with "wrangle"
---Replace with "strong"
+--Replace with: wrong
+--Replace with: prong
+--Replace with: rowing
+--Replace with: wrung
+--Replace with: wring
+--Replace with: wrangle
+--Replace with: throng
 --Add "wrrong" to dictionary
 --Ignore spelling for "wrrong"
-2: Spelling error: "spellled"
+2: Spelling error: spellled
 QUICKFIXES:
 Spelling Fixes
---Replace with "spelled"
---Replace with "spell led"
---Replace with "spell-led"
---Replace with "speller"
---Replace with "spanielled"
---Replace with "speedwell"
---Replace with "expelled"
---Replace with "spelldown"
---Replace with "splatted"
+--Replace with: spelled
+--Replace with: spell led
+--Replace with: spell-led
+--Replace with: spellable
+--Replace with: speller
+--Replace with: speedwell
+--Replace with: pelleted
+--Replace with: spelldown
+--Replace with: spellbind
 --Add "spellled" to dictionary
 --Ignore spelling for "spellled"

File test/data/Simple/QuickFix/Availability/v70/Mispeled.cs.gold

 }
 
 ------------------------------------------------
-0: Spelling error: "Mispeled"
+0: Spelling error: Mispeled
 QUICKFIXES:
 Spelling Fixes
---Replace with "Misspelled"
---Replace with "Dispelled"
---Replace with "Misspell"
---Replace with "Mislabeled"
---Replace with "Misplace"
---Replace with "Misapplier"
+--Replace with: Misspelled
+--Replace with: Dispelled
+--Replace with: Misspell
+--Replace with: Mislabeled
+--Replace with: Misplace
+--Replace with: Misapply
 --Add "Mispeled" to dictionary
 --Ignore spelling for "Mispeled"
-1: Spelling error: "mispeled"
+1: Spelling error: mispeled
 QUICKFIXES:
 Spelling Fixes
---Replace with "Misspelled"
---Replace with "Dispelled"
---Replace with "Misspell"
---Replace with "Mislabeled"
---Replace with "Misplace"
---Replace with "Misapplier"
+--Replace with: Misspelled
+--Replace with: Dispelled
+--Replace with: Misspell
+--Replace with: Mislabeled
+--Replace with: Misplace
+--Replace with: Misapply
 --Add "mispeled" to dictionary
 --Ignore spelling for "mispeled"
-2: Spelling error: "Mispeled"
+2: Spelling error: Mispeled
 QUICKFIXES:
 Spelling Fixes
---Replace with "Misspelled"
---Replace with "Dispelled"
---Replace with "Misspell"
---Replace with "Mislabeled"
---Replace with "Misplace"
---Replace with "Misapplier"
+--Replace with: Misspelled
+--Replace with: Dispelled
+--Replace with: Misspell
+--Replace with: Mislabeled
+--Replace with: Misplace
+--Replace with: Misapply
 --Add "Mispeled" to dictionary
 --Ignore spelling for "Mispeled"
-3: Spelling error: "Mispeled"
+3: Spelling error: Mispeled
 QUICKFIXES:
 Spelling Fixes
---Replace with "Misspelled"
---Replace with "Dispelled"
---Replace with "Misspell"
---Replace with "Mislabeled"
---Replace with "Misplace"
---Replace with "Misapplier"
+--Replace with: Misspelled
+--Replace with: Dispelled
+--Replace with: Misspell
+--Replace with: Mislabeled
+--Replace with: Misplace
+--Replace with: Misapply
 --Add "Mispeled" to dictionary
 --Ignore spelling for "Mispeled"
-4: Spelling error: "args"
+4: Spelling error: args
 QUICKFIXES:
 Spelling Fixes
---Replace with "rags"
---Replace with "gars"
---Replace with "ares"
---Replace with "ergs"
---Replace with "arts"
---Replace with "arcs"
---Replace with "arms"
---Replace with "arks"
---Replace with "argos"
---Replace with "argus"
+--Replace with: rags
+--Replace with: gars
+--Replace with: ares
+--Replace with: ergs
+--Replace with: arts
+--Replace with: arcs
+--Replace with: arms
+--Replace with: arks
+--Replace with: argus
+--Replace with: argos
 --Add "args" to dictionary
 --Ignore spelling for "args"
-5: Spelling error: "mispeled"