public void Execute(Action<DaemonStageResult> commiter)
{
var consumer = new DefaultHighlightingConsumer(this, settingsStore);
foreach (IFile psiFile in DaemonProcess.SourceFile.EnumeratePsiFiles())
{
psiFile.ProcessChildren<ITypeDeclaration>(declaration =>
{
if (declaration.DeclaredElement == null) // type is not (yet) declared
{
return;
}
RegistrationInfo registrationInfo = cachedComponentRegistrations.FirstOrDefault(c => c.Registration.IsSatisfiedBy(declaration.DeclaredElement));
if (registrationInfo != null)
{
consumer.AddHighlighting(new RegisteredByContainerHighlighting(registrationInfo),
declaration.GetNameDocumentRange(),
registrationInfo.GetRegistrationFile());
typeUsageManager.MarkTypeAsUsed(declaration);
}
});
}
commiter(new DaemonStageResult(consumer.Highlightings));
}
public void Execute(Action<DaemonStageResult> commiter)
{
var consumer = new DefaultHighlightingConsumer(this, settingsStore);
foreach (IFile psiFile in EnumeratePsiFiles())
{
ProcessFile(psiFile, consumer);
}
commiter(new DaemonStageResult(consumer.Highlightings));
}
public void Execute(Action <DaemonStageResult> committer)
{
var services = DaemonProcess.SourceFile.GetPsiServices();
services.Files.AssertAllDocumentAreCommitted();
var factory = new ShaderLabCodeFoldingProcessFactory();
var consumer = new DefaultHighlightingConsumer(this, mySettings);
myFile.ProcessDescendants(factory.CreateProcessor(), consumer);
var foldings = CodeFoldingUtil.AppendRangeWithOverlappingResolve(consumer.Highlightings);
committer(new DaemonStageResult(foldings));
}
public void Execute(Action<DaemonStageResult> committer)
{
MarkModulesAsUsed(collectUsagesStageProcess);
var consumer = new DefaultHighlightingConsumer(this, settingsStore);
var referenceProcessor = new RecursiveReferenceProcessor<IMvcReference>(reference =>
{
InterruptableActivityCookie.CheckAndThrow();
IHighlighting highlighting;
switch (reference.MvcKind)
{
case MvcKind.Area:
highlighting = CheckArea(reference);
break;
case MvcKind.Controller:
highlighting = CheckResolved(reference, _ => (IHighlighting)new MvcControllerHighlighting(_));
break;
case MvcKind.Action:
highlighting = CheckResolved(reference, _ => (IHighlighting)new MvcActionHighlighting(_));
break;
case MvcKind.View:
case MvcKind.PartialView:
case MvcKind.Master:
case MvcKind.DisplayTemplate:
case MvcKind.EditorTemplate:
case MvcKind.Template:
highlighting = CheckResolved(reference,
_ => (IHighlighting)new MvcViewHighlighting((IMvcViewReference)_));
break;
default:
highlighting = null;
break;
}
if (highlighting == null)
{
return;
}
consumer.AddHighlighting(highlighting, GetMvcReferenceHighlightingRange(reference),
reference.GetTreeNode().GetContainingFile());
});
foreach (IFile file in DaemonProcess.SourceFile.EnumerateDominantPsiFiles())
{
file.ProcessDescendants(referenceProcessor);
}
committer(new DaemonStageResult(consumer.Highlightings));
}
private void ProcessFile(IFile psiFile, DefaultHighlightingConsumer consumer)
{
foreach (var declaration in psiFile.ThisAndDescendants <ITypeDeclaration>())
{
if (declaration.DeclaredElement == null) // type is not (yet) declared
{
return;
}
RegistrationInfo registrationInfo = patternManager.GetRegistrationsForFile(psiFile.GetSourceFile()).
FirstOrDefault(c => c.Registration.IsSatisfiedBy(declaration.DeclaredElement));
if (registrationInfo != null)
{
consumer.AddHighlighting(new RegisteredByContainerHighlighting(registrationInfo), declaration.GetNameDocumentRange(), psiFile);
}
}
}
private void ProcessFile(IFile psiFile, DefaultHighlightingConsumer consumer)
{
foreach (var declaration in psiFile.ThisAndDescendants<ITypeDeclaration>())
{
if (declaration.DeclaredElement == null) // type is not (yet) declared
{
return;
}
RegistrationInfo registrationInfo = patternManager.GetRegistrationsForFile(psiFile.GetSourceFile()).
FirstOrDefault(c => c.Registration.IsSatisfiedBy(declaration.DeclaredElement));
if (registrationInfo != null)
{
consumer.AddHighlighting(new RegisteredByContainerHighlighting(registrationInfo), declaration.GetNameDocumentRange(), psiFile);
}
}
}
public void Execute(Action <DaemonStageResult> commiter)
{
var sourceFile = File.PhysicalPsiSourceFile;
if (sourceFile == null)
{
return;
}
var consumer = new DefaultHighlightingConsumer(sourceFile);
File.ProcessDescendants(this, consumer);
var solution = File.GetSolution();
var relevantHighlightings = consumer
.Highlightings
.Where(info => info.Range.Document.GetPsiSourceFile(solution) == sourceFile);
commiter(new DaemonStageResult(relevantHighlightings.ToArray()));
}
/// <summary>
/// Execute this stage of the process.
/// </summary>
/// <param name="commiter">The function to call when we've finished the stage to report the results.</param>
public void Execute(Action <DaemonStageResult> commiter)
{
IFile file = _daemonProcess.SourceFile.GetTheOnlyPsiFile(CSharpLanguage.Instance);
if (file == null)
{
return;
}
StringSettings stringSettings = _settingsStore.GetKey <StringSettings>(SettingsOptimization.OptimizeDefault);
if (!_daemonProcess.FullRehighlightingRequired)
{
return;
}
CommentAnalyzer commentAnalyzer = new CommentAnalyzer(_solution, _settingsStore);
IdentifierSpellCheckAnalyzer identifierAnalyzer = new IdentifierSpellCheckAnalyzer(_solution, _settingsStore, _daemonProcess.SourceFile);
#if RESHARPER20173
var consumer = new DefaultHighlightingConsumer(_daemonProcess.SourceFile);
#else
var consumer = new DefaultHighlightingConsumer(this, _settingsStore);
#endif
foreach (var classMemberDeclaration in file.Descendants <IClassMemberDeclaration>())
{
CheckMember(classMemberDeclaration, consumer, commentAnalyzer, identifierAnalyzer);
}
if (_daemonProcess.InterruptFlag)
{
return;
}
try
{
commiter(new DaemonStageResult(consumer.Highlightings));
} catch
{
// Do nothing if it doesn't work.
}
}
public override void Execute(Action <DaemonStageResult> commiter)
{
Action globalHighlighter = () =>
{
var consumer = new DefaultHighlightingConsumer(this, this.mySettingsStore);
this.File.ProcessThisAndDescendants(new GlobalProcessor(this, consumer));
commiter(
new DaemonStageResult(consumer.Highlightings)
{
Layer = 1
});
};
using (var fibers = this.DaemonProcess.CreateFibers())
{
fibers.EnqueueJob(globalHighlighter);
}
commiter(new DaemonStageResult(EmptyArray <HighlightingInfo> .Instance));
}
public override void Execute(Action<DaemonStageResult> commiter)
{
Action globalHighlighter = () =>
{
var consumer = new DefaultHighlightingConsumer(this, mySettingsStore);
File.ProcessThisAndDescendants(new GlobalProcessor(this, consumer));
commiter(new DaemonStageResult(consumer.Highlightings) { Layer = 1 });
};
using (IMultiCoreFibers fibers = DaemonProcess.CreateFibers())
{
// highlgiht global space
//if (DaemonProcess.FullRehighlightingRequired)
fibers.EnqueueJob(globalHighlighter);
}
// remove all old highlightings
//if (DaemonProcess.FullRehighlightingRequired)
commiter(new DaemonStageResult(EmptyArray<HighlightingInfo>.Instance));
}
public override void Execute(Action<DaemonStageResult> commiter)
{
Action globalHighlighter = () =>
{
var consumer = new DefaultHighlightingConsumer(this, this.mySettingsStore);
this.File.ProcessThisAndDescendants(new GlobalProcessor(this, consumer));
commiter(
new DaemonStageResult(consumer.Highlightings)
{
Layer = 1
});
};
using (var fibers = this.DaemonProcess.CreateFibers())
{
fibers.EnqueueJob(globalHighlighter);
}
commiter(new DaemonStageResult(EmptyArray<HighlightingInfo>.Instance));
}
private void CheckMember(IClassMemberDeclaration declaration,
DefaultHighlightingConsumer consumer, CommentAnalyzer commentAnalyzer, IdentifierSpellCheckAnalyzer identifierAnalyzer)
{
if (declaration is IConstructorDeclaration && declaration.IsStatic)
{
// TODO: probably need to put this somewhere in settings.
//Static constructors have no visibility so not clear how to check them.
return;
}
// Documentation doesn't work properly on multiple declarations (as of R# 6.1) so see if we can get it from the parent
XmlNode docNode = null;
IDocCommentBlock commentBlock;
IMultipleDeclarationMember multipleDeclarationMember = declaration as IMultipleDeclarationMember;
if (multipleDeclarationMember != null)
{
// get the parent
IMultipleDeclaration multipleDeclaration = multipleDeclarationMember.MultipleDeclaration;
// Now ask for the actual comment block
commentBlock = SharedImplUtil.GetDocCommentBlockNode(multipleDeclaration);
if (commentBlock != null)
{
docNode = commentBlock.GetXML(null);
}
}
else
{
commentBlock = SharedImplUtil.GetDocCommentBlockNode(declaration);
docNode = declaration.GetXMLDoc(false);
}
commentAnalyzer.CheckMemberHasComment(declaration, docNode, consumer);
commentAnalyzer.CheckCommentSpelling(declaration, commentBlock, consumer, true);
identifierAnalyzer.CheckMemberSpelling(declaration, consumer, true);
}
public static void CheckString(ICSharpLiteralExpression literalExpression,
DefaultHighlightingConsumer consumer, StringSettings settings, ISolution _solution, IContextBoundSettingsStore _settingsStore, IDaemonProcess _daemonProcess = null)
{
//ConstantValue val = literalExpression.ConstantValue;
// Ignore it unless it's something we're re-evalutating
if (_daemonProcess != null && !_daemonProcess.IsRangeInvalidated(literalExpression.GetDocumentRange()))
{
return;
}
ITokenNode tokenNode = literalExpression.Literal;
if (tokenNode == null)
{
return;
}
if (tokenNode.GetTokenType() == CSharpTokenType.STRING_LITERAL_VERBATIM)
{
if (settings.IgnoreVerbatimStrings)
{
return;
}
}
else if (tokenNode.GetTokenType() != CSharpTokenType.STRING_LITERAL_REGULAR)
{
return;
}
ISpellChecker spellChecker = SpellCheckManager.GetSpellChecker(_settingsStore, _solution, settings.DictionaryNames);
StringSpellChecker.SpellCheck(
literalExpression.GetDocumentRange()
.Document,
tokenNode,
spellChecker,
_solution, consumer, _settingsStore, settings);
}
public override void Execute(Action <DaemonStageResult> committer)
{
Action globalHighlighter = () =>
{
var consumer = new DefaultHighlightingConsumer(this, mySettingsStore);
File.ProcessThisAndDescendants(new GlobalProcessor(this, consumer));
committer(new DaemonStageResult(consumer.Highlightings)
{
Layer = 1
});
};
using (var fibers = DaemonProcess.CreateFibers())
{
// highlight global space
//if (DaemonProcess.FullRehighlightingRequired)
fibers.EnqueueJob(globalHighlighter);
}
// remove all old highlightings
//if (DaemonProcess.FullRehighlightingRequired)
committer(new DaemonStageResult(EmptyArray <HighlightingInfo> .Instance));
}
public void Execute(Action<DaemonStageResult> committer)
{
var nitraFile = ReSharperSolution.XXLanguageXXSolution.GetNitraFile(_daemonProcess.SourceFile);
if (nitraFile == null)
return;
var messages = nitraFile.GetCompilerMessages();
var highlightingInfos = new List<HighlightingInfo>(messages.Length);
var consumer = new DefaultHighlightingConsumer(this, _settings);
foreach (var message in messages)
{
if (_daemonProcess.InterruptFlag)
return;
var highlighting = new NitraError(message);
consumer.ConsumeHighlighting(new HighlightingInfo(highlighting.DocumentRange, highlighting));
//highlightingInfos.Add(new HighlightingInfo(highlighting.DocumentRange, highlighting));
}
committer(new DaemonStageResult(consumer.Highlightings));
//committer(new DaemonStageResult(highlightingInfos));
}
private void CheckWordSpelling(IClassMemberDeclaration decl, Range wordRange,
DefaultHighlightingConsumer consumer, DocumentRange range)
{
// If we dont have a spell checker then go no further
if (this._xmlDocumentationSpellChecker == null)
{
return;
}
// First check the whole word range.
if (!SpellCheckUtil.ShouldSpellCheck(wordRange.Word, _xmlDocumentationSettings.CompiledWordsToIgnore) ||
this._xmlDocumentationSpellChecker.TestWord(wordRange.Word, true))
{
return;
}
// We are checking this word and the whole range doesn't spell anything so try breaking the word into bits.
CamelHumpLexer camelHumpLexer = new CamelHumpLexer(wordRange.Word, 0, wordRange.Word.Length);
foreach (LexerToken humpToken in camelHumpLexer)
{
if (SpellCheckUtil.ShouldSpellCheck(humpToken.Value, _xmlDocumentationSettings.CompiledWordsToIgnore) &&
!this._xmlDocumentationSpellChecker.TestWord(humpToken.Value, true))
{
consumer.AddHighlighting(
new WordIsNotInDictionaryHighlight(
wordRange.Word,
range,
humpToken,
_solution,
this._xmlDocumentationSpellChecker,
_settingsStore),
range);
break;
}
}
}
/// <summary>
/// Execute this stage of the process.
/// </summary>
/// <param name="commiter">The function to call when we've finished the stage to report the results.</param>
public void Execute(Action <DaemonStageResult> commiter)
{
//var highlightings = new List<HighlightingInfo>();
IHighlightingConsumer highlightingConsumer = new DefaultHighlightingConsumer(
this, _settingsStore);
IFile file = _daemonProcess.SourceFile.GetTheOnlyPsiFile(CSharpLanguage.Instance);
if (file == null)
{
return;
}
if (!_daemonProcess.FullRehighlightingRequired)
{
return;
}
var commentAnalyzer = new CommentAnalyzer(_solution, _settingsStore);
var identifierAnalyzer = new IdentifierSpellCheckAnalyzer(_solution, _settingsStore, _daemonProcess.SourceFile);
file.ProcessChildren <IClassMemberDeclaration>(
declaration => CheckMember(
declaration, highlightingConsumer, commentAnalyzer, identifierAnalyzer));
if (_daemonProcess.InterruptFlag)
{
return;
}
try
{
commiter(new DaemonStageResult(highlightingConsumer.Highlightings));
} catch
{
// Do nothing if it doesn't work.
}
}
public void CheckCommentSpelling(IClassMemberDeclaration decl, [CanBeNull] IDocCommentBlock docNode,
DefaultHighlightingConsumer consumer, bool spellCheck)
{
if (docNode == null)
{
return;
}
IFile file = decl.GetContainingFile();
if (file == null)
{
return;
}
foreach (Range wordRange in this.GetWordsFromXmlComment(docNode))
{
DocumentRange range = file.GetDocumentRange(wordRange.TreeTextRange);
string word = wordRange.Word;
if (decl.DeclaredName != word)
{
if ((IdentifierResolver.IsIdentifier(decl, _solution, word, _identifierSettings.IdentifierLookupScope) ||
IdentifierResolver.IsKeyword(decl, _solution, word)) &&
IdentifierResolver.AnalyzeForMetaTagging(word, _xmlDocumentationSettings.CompiledWordsToIgnoreForMetatagging))
{
consumer.AddHighlighting(
new CanBeSurroundedWithMetatagsHighlight(word, range, decl, _solution),
range);
}
else if (spellCheck)
{
this.CheckWordSpelling(decl, wordRange, consumer, range);
}
}
}
}
/// <summary>
/// Execute this stage of the process.
/// </summary>
/// <param name="commiter">The function to call when we've finished the stage to report the results.</param>
public void Execute(Action <DaemonStageResult> commiter)
{
IFile file = this._daemonProcess.SourceFile.GetTheOnlyPsiFile(CSharpLanguage.Instance);
if (file == null)
{
return;
}
#if RESHARPER20173
var consumer = new DefaultHighlightingConsumer(_daemonProcess.SourceFile);
#else
var consumer = new DefaultHighlightingConsumer(this, _settingsStore);
#endif
StringSettings stringSettings = this._settingsStore.GetKey <StringSettings>(SettingsOptimization.OptimizeDefault);
foreach (var literalExpression in file.Descendants <ICSharpLiteralExpression>())
{
CheckString(literalExpression, consumer, stringSettings, _solution, _settingsStore, _daemonProcess);
}
foreach (var literalExpression in file.Descendants <IInterpolatedStringExpression>())
{
CheckString(literalExpression, consumer, stringSettings, _solution, _settingsStore, _daemonProcess);
}
try
{
commiter(new DaemonStageResult(consumer.Highlightings));
}
catch
{
// Do nothing if it doesn't work.
}
}
public void CheckComment(ICSharpCommentNode commentNode,
DefaultHighlightingConsumer consumer, CommentSettings settings)
{
// Ignore it unless it's something we're re-evalutating
if (!_daemonProcess.IsRangeInvalidated(commentNode.GetDocumentRange()))
{
return;
}
// Only look for ones that are not doc comments
if (commentNode.CommentType != CommentType.END_OF_LINE_COMMENT &&
commentNode.CommentType != CommentType.MULTILINE_COMMENT)
{
return;
}
ISpellChecker spellChecker = SpellCheckManager.GetSpellChecker(_settingsStore, _solution, settings.DictionaryNames);
SpellCheck(
commentNode.GetDocumentRange().Document,
commentNode,
spellChecker,
_solution, consumer, _settingsStore, settings);
}
/// <summary>
/// Execute this stage of the process.
/// </summary>
/// <param name="commiter">The function to call when we've finished the stage to report the results.</param>
public void Execute(Action <DaemonStageResult> commiter)
{
IFile file = _daemonProcess.SourceFile.GetTheOnlyPsiFile(CSharpLanguage.Instance);
if (file == null)
{
return;
}
var highlightingConsumer = new DefaultHighlightingConsumer(this, _settingsStore);
var commentSettings = _settingsStore.GetKey <CommentSettings>(SettingsOptimization.OptimizeDefault);
file.ProcessChildren <ICSharpCommentNode>(commentNode
=> CheckComment(commentNode, highlightingConsumer, commentSettings));
try
{
commiter(new DaemonStageResult(highlightingConsumer.Highlightings));
}
catch
{
// Do nothing if it doesn't work.
}
}
public static void SpellCheck(IDocument document, ITokenNode token, ISpellChecker spellChecker,
ISolution solution, DefaultHighlightingConsumer consumer, IContextBoundSettingsStore settingsStore, StringSettings settings)
{
if (spellChecker == null)
{
return;
}
string buffer = unescape(token.GetText());
ILexer wordLexer = new WordLexer(buffer);
wordLexer.Start();
while (wordLexer.TokenType != null)
{
string tokenText = wordLexer.GetCurrTokenText();
if (SpellCheckUtil.ShouldSpellCheck(tokenText, settings.CompiledWordsToIgnore) &&
!spellChecker.TestWord(tokenText, true))
{
IClassMemberDeclaration containingElement =
token.GetContainingNode <IClassMemberDeclaration>(false);
if (containingElement == null ||
!IdentifierResolver.IsIdentifier(containingElement, solution, tokenText))
{
CamelHumpLexer camelHumpLexer = new CamelHumpLexer(buffer, wordLexer.TokenStart, wordLexer.TokenEnd);
foreach (LexerToken humpToken in camelHumpLexer)
{
if (SpellCheckUtil.ShouldSpellCheck(humpToken.Value, settings.CompiledWordsToIgnore) &&
!spellChecker.TestWord(humpToken.Value, true))
{
//int start = token.GetTreeStartOffset().Offset + wordLexer.TokenStart;
//int end = start + tokenText.Length;
//TextRange range = new TextRange(start, end);
//DocumentRange documentRange = new DocumentRange(document, range);
DocumentRange documentRange =
token.GetContainingFile().TranslateRangeForHighlighting(token.GetTreeTextRange());
documentRange = documentRange.ExtendLeft(-wordLexer.TokenStart);
documentRange = documentRange.ExtendRight(-1 * (documentRange.GetText().Length - tokenText.Length));
TextRange textRange = new TextRange(humpToken.Start - wordLexer.TokenStart,
humpToken.End - wordLexer.TokenStart);
//string word = document.GetText(range);
string word = documentRange.GetText();
consumer.AddHighlighting(
new StringSpellCheckHighlighting(
word,
documentRange,
humpToken.Value,
textRange,
solution,
spellChecker,
settingsStore),
documentRange);
break;
}
}
}
}
wordLexer.Advance();
}
}
public TestFileAnalysisElementProcessor(TestFileAnalysisDaemonStageProcess stageProcess, IDaemonProcess process, IContextBoundSettingsStore settings)
{
_highlightingConsumer = new FilteringHighlightingConsumer(stageProcess.File.GetSourceFile(), stageProcess.File);
_process = process;
_settings = settings;
}
/// <summary>
/// Check that the given declaration has an xml documentation comment.
/// </summary>
/// <param name="declaration">The declaration to check</param>
/// <param name="docNode">The documentation node to check.</param>
/// <param name="consumer">The list of highlights (errors) that were found - add to this any new issues</param>
public void CheckMemberHasComment(IClassMemberDeclaration declaration, [CanBeNull] XmlNode docNode,
DefaultHighlightingConsumer consumer)
{
// Only process this one if its range is invalid.
//if (!_daemonProcess.IsRangeInvalidated(declaration.GetDocumentRange())) return;
// Check if the parent doco is null
if (_xmlDocumentationSettings.SuppressIfBaseHasComment)
{
if (docNode == null && declaration.GetXMLDoc(true) != null)
{
return;
}
}
if (docNode != null)
{
return;
}
//check if project should be ignored
if (ShouldIgnoreProject(declaration.GetProject()?.Name))
{
return;
}
Match[] publicMembers = new[]
{
new Match(
Declaration.Any, AccessLevels.Public | AccessLevels.Protected | AccessLevels.ProtectedInternal)
};
Match[] internalMembers = new[] { new Match(Declaration.Any, AccessLevels.Internal) };
Match[] privateMembers = new[] { new Match(Declaration.Any, AccessLevels.Private) };
Match match = ComplexMatchEvaluator.IsMatch(declaration, privateMembers, null, true);
IFile containingFile = declaration.GetContainingFile();
if (match != null)
{
consumer.AddHighlighting(
new PrivateMemberMissingXmlCommentHighlighting(declaration, match),
containingFile.TranslateRangeForHighlighting(declaration.GetNameRange()));
return;
}
match = ComplexMatchEvaluator.IsMatch(declaration, internalMembers, null, true);
if (match != null)
{
consumer.AddHighlighting(
new InternalMemberMissingXmlCommentHighlighting(declaration, match),
containingFile.TranslateRangeForHighlighting(declaration.GetNameRange()));
return;
}
match = ComplexMatchEvaluator.IsMatch(declaration, publicMembers, null, true);
if (match != null)
{
consumer.AddHighlighting(
new PublicMemberMissingXmlCommentHighlighting(declaration, match),
containingFile.TranslateRangeForHighlighting(declaration.GetNameRange()));
}
}
public void CheckMemberSpelling(IDeclaration declaration, DefaultHighlightingConsumer consumer, bool spellCheck)
{
if (this._identifierSpellChecker == null || !spellCheck)
{
return;
}
if (declaration is IIndexerDeclaration ||
declaration is IDestructorDeclaration ||
declaration is IAccessorDeclaration ||
declaration is IConstructorDeclaration ||
(declaration.DeclaredName.Contains(".") && !(declaration is INamespaceDeclaration)))
{
return;
}
/*if (ComplexMatchEvaluator.IsMatch(declaration, _settings.IdentifiersToSpellCheck,
* _settings.IdentifiersNotToSpellCheck, true) == null)
* {
* return null;
* }*/
HashSet <string> localNames = getLocalNames(declaration);
CamelHumpLexer lexer =
new CamelHumpLexer(declaration.DeclaredName, 0, declaration.DeclaredName.Length);
foreach (LexerToken token in lexer)
{
string val = token.Value;
string lowerVal = val.ToLower();
//val.Length > MAX_LENGTH_TO_SKIP &&
if (
!IsAbbreviation(val) &&
SpellCheckUtil.ShouldSpellCheck(val, _identifierSettings.CompiledWordsToIgnore) &&
!localNames.Contains(lowerVal) &&
!this._identifierSpellChecker.TestWord(val, false))
{
bool found = false;
foreach (string entry in localNames)
{
if (entry.StartsWith(lowerVal))
{
found = true;
break;
}
}
if (!found)
{
var containingFile = declaration.GetContainingFile();
consumer.AddHighlighting(
new IdentifierSpellCheckHighlighting(
declaration,
token,
_solution,
this._identifierSpellChecker,
_settingsStore),
containingFile.TranslateRangeForHighlighting(declaration.GetNameRange()));
}
}
}
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="committer">
/// The committer.
/// </param>
public void Execute(Action <DaemonStageResult> committer)
{
StyleCopTrace.In();
try
{
if (this.daemonProcess == null)
{
return;
}
if (this.daemonProcess.InterruptFlag)
{
return;
}
DaemonData daemonData;
bool shouldProcessNow;
daemonData = this.file.UserData.GetOrCreateDataUnderLock(
DaemonDataKey,
() => new DaemonData(this.lifetime, this.threading, this.daemon, this.daemonProcess.Document));
shouldProcessNow = daemonData.OnDaemonCalled();
if (shouldProcessNow)
{
Lifetime.Using(
apiLifetime =>
{
var runner = this.apiPool.GetInstance(apiLifetime).Runner;
runner.Execute(
this.daemonProcess.SourceFile.ToProjectFile(),
this.daemonProcess.Document,
this.file);
// This filters the highlights, based on "ReSharper disable" comments, etc.
var defaultConsumer = new DefaultHighlightingConsumer(this.daemonProcess.SourceFile);
var filteringConsumer = new FilteringHighlightingConsumer(
defaultConsumer,
this.daemonProcess.SourceFile,
this.file,
this.settings);
foreach (var highlightingInfo in runner.ViolationHighlights)
{
filteringConsumer.ConsumeHighlighting(highlightingInfo);
}
committer(new DaemonStageResult(filteringConsumer.Highlightings));
});
}
else
{
// NOTE: This wouldn't be necessary if the StyleCop analysis were more lightweight,
// e.g. by using ReSharper's ASTs rather than re-parsing the file on each change
daemonData.ScheduleReHighlight();
}
}
catch (OperationCanceledException)
{
}
StyleCopTrace.Out();
}