private static DiagnosticAnalyzerService CreateDiagnosticAnalyzerService(
Dictionary<string, DiagnosticAnalyzer[]> analyzerMap, IAsynchronousOperationListener listener)
{
return analyzerMap == null || analyzerMap.Count == 0
? new MyDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap(), listener: listener)
: new MyDiagnosticAnalyzerService(analyzerMap.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()), listener: listener);
}
/// <summary>
/// Given an analyzer and a collection of documents to apply it to, run the analyzer and gather an array of
/// diagnostics found. The returned diagnostics are then ordered by location in the source documents.
/// </summary>
/// <param name="analyzers">The analyzer to run on the documents.</param>
/// <param name="documents">The <see cref="Document"/>s that the analyzer will be run on.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
/// <returns>A collection of <see cref="Diagnostic"/>s that surfaced in the source code, sorted by
/// <see cref="Diagnostic.Location"/>.</returns>
protected static async Task<ImmutableArray<Diagnostic>> GetSortedDiagnosticsFromDocumentsAsync(ImmutableArray<DiagnosticAnalyzer> analyzers, Document[] documents, CancellationToken cancellationToken)
{
var projects = new HashSet<Project>();
foreach (var document in documents)
{
projects.Add(document.Project);
}
var supportedDiagnosticsSpecificOptions = new Dictionary<string, ReportDiagnostic>();
foreach (var analyzer in analyzers)
{
foreach (var diagnostic in analyzer.SupportedDiagnostics)
{
// make sure the analyzers we are testing are enabled
supportedDiagnosticsSpecificOptions[diagnostic.Id] = ReportDiagnostic.Default;
}
}
// Report exceptions during the analysis process as errors
supportedDiagnosticsSpecificOptions.Add("AD0001", ReportDiagnostic.Error);
var diagnostics = ImmutableArray.CreateBuilder<Diagnostic>();
foreach (var project in projects)
{
// update the project compilation options
var modifiedSpecificDiagnosticOptions = supportedDiagnosticsSpecificOptions.ToImmutableDictionary().SetItems(project.CompilationOptions.SpecificDiagnosticOptions);
var modifiedCompilationOptions = project.CompilationOptions.WithSpecificDiagnosticOptions(modifiedSpecificDiagnosticOptions);
var processedProject = project.WithCompilationOptions(modifiedCompilationOptions);
var compilation = await processedProject.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var compilationWithAnalyzers = compilation.WithAnalyzers(analyzers, processedProject.AnalyzerOptions, cancellationToken);
var compilerDiagnostics = compilation.GetDiagnostics(cancellationToken);
var compilerErrors = compilerDiagnostics.Where(i => i.Severity == DiagnosticSeverity.Error);
var diags = await compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().ConfigureAwait(false);
var allDiagnostics = await compilationWithAnalyzers.GetAllDiagnosticsAsync().ConfigureAwait(false);
var failureDiagnostics = allDiagnostics.Where(diagnostic => diagnostic.Id == "AD0001");
foreach (var diag in diags.Concat(compilerErrors).Concat(failureDiagnostics))
{
if (diag.Location == Location.None || diag.Location.IsInMetadata)
{
diagnostics.Add(diag);
}
else
{
for (int i = 0; i < documents.Length; i++)
{
var document = documents[i];
var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
if (tree == diag.Location.SourceTree)
{
diagnostics.Add(diag);
}
}
}
}
}
var results = SortDistinctDiagnostics(diagnostics);
return results.ToImmutableArray();
}
public void Setup()
{
_dictionary = Enumerable.Range(1, Size).ToDictionary(_ => "test " + _, _ => _);
_readonlyDictionary = new ReadonlyDictionary<string, int>(_dictionary);
_concurrentDictionary = new ConcurrentDictionary<string, int>(_dictionary);
_immutableDictionary = _dictionary.ToImmutableDictionary();
}
public HtmlFile ReadFile(HtmlFile file)
{
CommonMarkSettings.Default.OutputDelegate =
(document, output, settings) =>
new CustomHtmlFormatter(output, settings, file).WriteDocument(document);
var doc = CommonMarkConverter.Parse(file.Source);
var properties = new Dictionary<string, string>();
foreach(var node in doc.AsEnumerable())
{
if(node.Block?.Tag == BlockTag.FencedCode)
{
if(node.Block.StringContent.TakeFromStart(PropertiesString.Length) == PropertiesString)
{
string kvString = node.Block.StringContent.ToString().Substring(PropertiesString.Length);
var propDict = ReadKV(kvString);
propDict.ToList().ForEach(x => properties.Add(x.Key, x.Value));
}
}
}
StringBuilder sb = new StringBuilder();
CommonMarkConverter.ProcessStage3(doc, new StringWriter(sb));
return file.WithContent(sb.ToString()).WithProperties(properties.ToImmutableDictionary());
}
private static ImmutableDictionary<ErrorCode, string> CreateHelpLinks()
{
var map = new Dictionary<ErrorCode, string>()
{
// { ERROR_CODE, HELP_LINK }
};
return map.ToImmutableDictionary();
}
private static ImmutableDictionary<ErrorCode, string> CreateCategoriesMap()
{
var map = new Dictionary<ErrorCode, string>()
{
// { ERROR_CODE, CATEGORY }
};
return map.ToImmutableDictionary();
}
public void Build(FileModel model, IHostService host)
{
model.File = Path.ChangeExtension(model.File, ".json");
var toc = (TocViewModel)model.Content;
HashSet<string> links = new HashSet<string>();
Dictionary<string, HashSet<string>> tocMap = new Dictionary<string, HashSet<string>>();
UpdateRelativePathAndAddTocMap(toc, model, links, tocMap, host);
model.Properties.LinkToFiles = links.ToImmutableArray();
model.Properties.TocMap = tocMap.ToImmutableDictionary();
// todo : metadata.
}
private static void GetTagSource(TestWorkspace workspace, DiagnosticServiceWaiter diagnosticWaiter, ErrorSquiggleWaiter squiggleWaiter, out Analyzer analyzer, out DiagnosticAnalyzerService analyzerService, out DiagnosticsSquiggleTaggerProvider.TagSource taggerSource)
{
analyzer = new Analyzer();
var analyzerMap = new Dictionary<string, ImmutableArray<DiagnosticAnalyzer>>() { { LanguageNames.CSharp, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer) } };
analyzerService = new DiagnosticAnalyzerService(analyzerMap.ToImmutableDictionary());
var diagnosticListeners = SpecializedCollections.SingletonEnumerable(new Lazy<IAsynchronousOperationListener, FeatureMetadata>(
() => diagnosticWaiter, new FeatureMetadata(new Dictionary<string, object>() { { "FeatureName", FeatureAttribute.DiagnosticService } })));
var diagnosticService = new DiagnosticService(SpecializedCollections.SingletonEnumerable<IDiagnosticUpdateSource>(analyzerService), diagnosticListeners);
var document = workspace.Documents.First();
var buffer = document.GetTextBuffer();
var foregroundService = new TestForegroundNotificationService();
var optionsService = workspace.Services.GetService<IOptionService>();
taggerSource = new DiagnosticsSquiggleTaggerProvider.TagSource(buffer, foregroundService, diagnosticService, optionsService, squiggleWaiter);
}
/// <summary>
/// The settings provider used to bridge Service Fabric configuration information and DotNetty
/// </summary>
/// <param name="traceId">The unique identifier used to correlate debugging and diagnostics messages</param>
/// <param name="componentName">The component name used for debug and diagnostics messages</param>
/// <param name="logger">The service fabric logger to be used when writing debug and diagnostics information</param>
/// <param name="gatewayConfiguration">The gateway configuration used to get current configuration information for DotNetty</param>
/// <param name="iotHubConfiguration">The IotHub Client configuration used to get current configuration information for DotNetty</param>
/// <param name="mqttConfiguration">The MQTT configuration used to get current configuration information for DotNetty</param>
public ServiceFabricConfigurationProvider(Guid traceId, string componentName, IServiceLogger logger, GatewayConfiguration gatewayConfiguration, IoTHubConfiguration iotHubConfiguration, MqttServiceConfiguration mqttConfiguration)
{
this.componentName = componentName;
this.logger = logger;
this.logger.Verbose(traceId, this.componentName, "Initializing configuration provider.");
var baseProperties = new Dictionary<string, string>();
foreach (PropertyInfo element in typeof(GatewayConfiguration).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (!element.PropertyType.IsArray)
{
object value = element.GetValue(gatewayConfiguration, null);
baseProperties.Add(element.Name, element.PropertyType == typeof(string) ? value as string : value.ToString());
}
}
foreach (PropertyInfo element in typeof(MqttServiceConfiguration).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (!element.PropertyType.IsArray)
{
object value = element.GetValue(mqttConfiguration, null);
baseProperties.Add(element.Name, element.PropertyType == typeof(string) ? value as string : value.ToString());
}
}
foreach (PropertyInfo element in typeof(IoTHubConfiguration).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (!element.PropertyType.IsArray)
{
object value = element.GetValue(iotHubConfiguration, null);
baseProperties.Add($"IotHubClient.{element.Name}", value?.ToString());
}
}
this.configurationValues = baseProperties.ToImmutableDictionary();
this.logger.Informational(traceId, this.componentName, "Initializing configuration provider complete.");
}
public static void IndexSolutions(IEnumerable<string> solutionFilePaths, Dictionary<string, string> properties)
{
var assemblyNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var path in solutionFilePaths)
{
using (Disposable.Timing("Reading assembly names from " + path))
{
foreach (var assemblyName in AssemblyNameExtractor.GetAssemblyNames(path))
{
assemblyNames.Add(assemblyName);
}
}
}
var federation = new Federation();
foreach (var path in solutionFilePaths)
{
using (Disposable.Timing("Generating " + path))
{
using (var solutionGenerator = new SolutionGenerator(
path,
Paths.SolutionDestinationFolder,
properties: properties.ToImmutableDictionary(),
federation: federation))
{
solutionGenerator.GlobalAssemblyList = assemblyNames;
solutionGenerator.Generate(solutionExplorerRoot: mergedSolutionExplorerRoot);
if (Configuration.ProcessReferencies)
Extend.ExtendGenerator.TopReferencedAssemblies(solutionGenerator, federation, mergedSolutionExplorerRoot);
}
}
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
}
}
private static void IndexSolutions(IEnumerable<string> solutionFilePaths, Dictionary<string, string> properties, Federation federation, Dictionary<string, string> serverPathMappings)
{
var assemblyNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var path in solutionFilePaths)
{
using (Disposable.Timing("Reading assembly names from " + path))
{
foreach (var assemblyName in AssemblyNameExtractor.GetAssemblyNames(path))
{
assemblyNames.Add(assemblyName);
}
}
}
foreach (var path in solutionFilePaths)
{
using (Disposable.Timing("Generating " + path))
{
using (var solutionGenerator = new SolutionGenerator(
path,
Paths.SolutionDestinationFolder,
properties: properties.ToImmutableDictionary(),
federation: federation,
serverPathMappings: serverPathMappings))
{
solutionGenerator.GlobalAssemblyList = assemblyNames;
solutionGenerator.Generate(solutionExplorerRoot: mergedSolutionExplorerRoot);
}
}
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
}
}
private static void HandleAsteriskToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
{
if (token.IsMissing)
{
return;
}
bool allowAtLineStart;
bool allowAtLineEnd;
bool allowPrecedingSpace;
bool allowTrailingSpace;
switch (token.Parent.Kind())
{
case SyntaxKind.PointerType:
allowAtLineStart = false;
allowAtLineEnd = true;
allowPrecedingSpace = false;
var nextToken = token.GetNextToken();
switch (nextToken.Kind())
{
case SyntaxKind.OpenBracketToken:
case SyntaxKind.OpenParenToken:
allowTrailingSpace = false;
break;
default:
allowTrailingSpace = true;
break;
}
break;
case SyntaxKind.PointerIndirectionExpression:
allowAtLineStart = true;
allowAtLineEnd = false;
allowTrailingSpace = false;
var prevToken = token.GetPreviousToken();
switch (prevToken.Kind())
{
case SyntaxKind.OpenBracketToken:
case SyntaxKind.OpenParenToken:
case SyntaxKind.CloseParenToken:
allowPrecedingSpace = false;
break;
default:
allowPrecedingSpace = true;
break;
}
break;
default:
return;
}
bool firstInLine = token.IsFirstInLine();
bool precededBySpace = firstInLine || token.IsPrecededByWhitespace();
bool followedBySpace = token.IsFollowedByWhitespace();
bool lastInLine = token.IsLastInLine();
if (!allowAtLineStart && firstInLine)
{
// Dereference symbol '*' must {not appear at the beginning of a line}.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), "not appear at the beginning of a line"));
}
else if (!allowPrecedingSpace && precededBySpace)
{
// Dereference symbol '*' must {not be preceded by a space}.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), "not be preceded by a space"));
}
if (!allowAtLineEnd && lastInLine)
{
// Dereference symbol '*' must {not appear at the end of a line}.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), "not appear at the end of a line"));
}
else if (!allowTrailingSpace && followedBySpace)
{
// Dereference symbol '*' must {not be followed by a space}.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), "not be followed by a space"));
}
if (!followedBySpace && allowTrailingSpace)
{
// Dereference symbol '*' must {be followed by a space}.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), "be followed by a space"));
}
}
private static void HandleCloseBraceToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
{
if (token.IsMissing)
{
return;
}
bool precededBySpace = token.IsFirstInLine() || token.IsPrecededByWhitespace();
if (token.Parent is InterpolationSyntax)
{
if (precededBySpace)
{
// Closing curly bracket must{ not} be {preceded} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "preceded"));
}
return;
}
bool followedBySpace = token.IsFollowedByWhitespace();
bool lastInLine = token.IsLastInLine();
bool precedesSpecialCharacter;
if (!followedBySpace && !lastInLine)
{
SyntaxToken nextToken = token.GetNextToken();
precedesSpecialCharacter =
nextToken.IsKind(SyntaxKind.CloseParenToken)
|| nextToken.IsKind(SyntaxKind.CommaToken)
|| nextToken.IsKind(SyntaxKind.SemicolonToken)
|| nextToken.IsKind(SyntaxKind.DotToken)
|| (nextToken.IsKind(SyntaxKind.QuestionToken) && nextToken.GetNextToken(includeZeroWidth: true).IsKind(SyntaxKind.DotToken))
|| nextToken.IsKind(SyntaxKind.CloseBracketToken);
}
else
{
precedesSpecialCharacter = false;
}
if (!precededBySpace)
{
// Closing curly bracket must{} be {preceded} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), string.Empty, "preceded"));
}
if (!lastInLine && !precedesSpecialCharacter && !followedBySpace)
{
// Closing curly bracket must{} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), string.Empty, "followed"));
}
}
private static void HandleCloseParenToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
{
if (token.IsMissing)
{
return;
}
bool precededBySpace = token.IsFirstInLine() || token.IsPrecededByWhitespace();
bool followedBySpace = token.IsFollowedByWhitespace();
bool lastInLine = token.IsLastInLine();
bool precedesStickyCharacter;
bool allowEndOfLine = false;
bool suppressFollowingSpaceError = false;
SyntaxToken nextToken = token.GetNextToken();
switch (nextToken.Kind())
{
case SyntaxKind.OpenParenToken:
case SyntaxKind.CloseParenToken:
case SyntaxKind.OpenBracketToken:
case SyntaxKind.CloseBracketToken:
case SyntaxKind.SemicolonToken:
case SyntaxKind.CommaToken:
precedesStickyCharacter = true;
break;
case SyntaxKind.QuestionToken:
if (nextToken.Parent.IsKind(SyntaxKind.ConditionalAccessExpression))
{
// allow a space for this case, but only if the ')' character is the last on the line
allowEndOfLine = true;
precedesStickyCharacter = true;
}
else
{
precedesStickyCharacter = false;
}
break;
case SyntaxKind.PlusToken:
precedesStickyCharacter = nextToken.Parent.IsKind(SyntaxKind.UnaryPlusExpression);
// this will be reported as SA1022
suppressFollowingSpaceError = true;
break;
case SyntaxKind.MinusToken:
precedesStickyCharacter = nextToken.Parent.IsKind(SyntaxKind.UnaryMinusExpression);
// this will be reported as SA1021
suppressFollowingSpaceError = true;
break;
case SyntaxKind.DotToken:
// allow a space for this case, but only if the ')' character is the last on the line
allowEndOfLine = true;
precedesStickyCharacter = true;
break;
case SyntaxKind.ColonToken:
bool requireSpace =
nextToken.Parent.IsKind(SyntaxKind.ConditionalExpression)
|| nextToken.Parent.IsKind(SyntaxKind.BaseConstructorInitializer)
|| nextToken.Parent.IsKind(SyntaxKind.ThisConstructorInitializer);
precedesStickyCharacter = !requireSpace;
break;
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
precedesStickyCharacter = true;
suppressFollowingSpaceError = false;
break;
case SyntaxKind.CloseBraceToken:
precedesStickyCharacter = nextToken.Parent is InterpolationSyntax;
break;
default:
precedesStickyCharacter = false;
break;
}
switch (token.Parent.Kind())
{
case SyntaxKind.CastExpression:
precedesStickyCharacter = true;
break;
default:
break;
}
if (precededBySpace)
{
// Closing parenthesis must{ not} be {preceded} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "preceded"));
}
if (!suppressFollowingSpaceError)
{
if (!precedesStickyCharacter && !followedBySpace && !lastInLine)
{
// Closing parenthesis must{} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), string.Empty, "followed"));
}
else if (precedesStickyCharacter && followedBySpace && (!lastInLine || !allowEndOfLine))
{
// Closing parenthesis must{ not} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "followed"));
}
}
}
private static void CheckIfLocationOfPreviousTokenAndOpenTokenAreTheSame(SyntaxNodeAnalysisContext context, SyntaxToken openToken, bool preserveLayout)
{
var previousToken = openToken.GetPreviousToken();
if (previousToken.IsMissing)
{
return;
}
var prevTokenLine = previousToken.GetLineSpan();
var openParenLine = openToken.GetLineSpan();
if (prevTokenLine.IsValid &&
openParenLine.IsValid &&
openParenLine.StartLinePosition.Line != prevTokenLine.StartLinePosition.Line)
{
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove,
[OpenCloseSpacingCodeFixProvider.LayoutKey] = preserveLayout ? OpenCloseSpacingCodeFixProvider.LayoutPreserve : OpenCloseSpacingCodeFixProvider.LayoutPack
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, openToken.GetLocation(), properties.ToImmutableDictionary()));
}
}
private static void HandleOpenBraceToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
{
if (token.IsMissing)
{
return;
}
bool followedBySpace = token.IsFollowedByWhitespace();
if (token.Parent is InterpolationSyntax)
{
if (followedBySpace)
{
// Opening curly bracket must{} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "followed"));
}
return;
}
bool precededBySpace = token.IsFirstInLine() || token.IsPrecededByWhitespace();
if (!precededBySpace)
{
// Opening curly bracket must{} be {preceded} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), string.Empty, "preceded"));
}
if (!token.IsLastInLine() && !followedBySpace)
{
// Opening curly bracket must{} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), string.Empty, "followed"));
}
}
private ImmutableDictionary<string, FileAndType> GetAllSourceFiles(IEnumerable<FileAndType> allSourceFiles)
{
var dict = new Dictionary<string, FileAndType>(TypeForwardedToFilePathComparer.OSPlatformSensitiveStringComparer);
foreach (var item in allSourceFiles)
{
var path = (string)((TypeForwardedToRelativePath)item.File).GetPathFromWorkingFolder();
FileAndType ft;
if (dict.TryGetValue(path, out ft))
{
if (TypeForwardedToFilePathComparer.OSPlatformSensitiveStringComparer.Equals(ft.BaseDir, item.BaseDir) &&
TypeForwardedToFilePathComparer.OSPlatformSensitiveStringComparer.Equals(ft.File, item.File))
{
if (ft.Type >= item.Type)
{
Logger.LogWarning($"Ignored duplicate file {Path.Combine(item.BaseDir, item.File)}.");
continue;
}
else
{
Logger.LogWarning($"Ignored duplicate file {Path.Combine(ft.BaseDir, ft.File)}.");
}
}
else
{
if (ft.Type >= item.Type)
{
Logger.LogWarning($"Ignored conflict file {Path.Combine(item.BaseDir, item.File)} for {path} by {Path.Combine(ft.BaseDir, ft.File)}.");
continue;
}
else
{
Logger.LogWarning($"Ignored conflict file {Path.Combine(ft.BaseDir, ft.File)} for {path} by {Path.Combine(item.BaseDir, item.File)}.");
}
}
}
dict[path] = item;
}
return dict.ToImmutableDictionary(TypeForwardedToFilePathComparer.OSPlatformSensitiveStringComparer);
}
private static ImmutableDictionary<FixAllProvider, ImmutableHashSet<string>> GetAllFixAllProviders(IEnumerable<CodeFixProvider> providers)
{
Dictionary<FixAllProvider, ImmutableHashSet<string>> fixAllProviders = new Dictionary<FixAllProvider, ImmutableHashSet<string>>();
foreach (var provider in providers)
{
var fixAllProvider = provider.GetFixAllProvider();
var supportedDiagnosticIds = fixAllProvider.GetSupportedFixAllDiagnosticIds(provider);
foreach (var id in supportedDiagnosticIds)
{
fixAllProviders.AddToInnerSet(fixAllProvider, id);
}
}
return fixAllProviders.ToImmutableDictionary();
}
private static void HandleIncrementDecrementToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
{
if (token.IsMissing)
{
return;
}
switch (token.Parent.Kind())
{
case SyntaxKind.PreIncrementExpression:
case SyntaxKind.PreDecrementExpression:
if (token.HasTrailingTrivia)
{
string symbolName;
if (token.IsKind(SyntaxKind.MinusMinusToken))
{
symbolName = "Decrement";
}
else
{
symbolName = "Increment";
}
// {Increment|Decrement} symbol '{++|--}' must not be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove,
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), symbolName, token.Text, "followed"));
}
break;
case SyntaxKind.PostIncrementExpression:
case SyntaxKind.PostDecrementExpression:
SyntaxToken previousToken = token.GetPreviousToken();
if (!previousToken.IsMissing && previousToken.HasTrailingTrivia)
{
string symbolName;
if (token.IsKind(SyntaxKind.MinusMinusToken))
{
symbolName = "Decrement";
}
else
{
symbolName = "Increment";
}
// {Increment|Decrement} symbol '{++|--}' must not be {preceded} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove,
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), symbolName, token.Text, "preceded"));
}
break;
default:
return;
}
}
internal void CreateSourceAssemblyForCompilation(PhpCompilation compilation)
{
if (compilation._lazyAssemblySymbol != null)
return;
// TODO: lock
Debug.Assert(_lazyExplicitReferences.IsDefault);
Debug.Assert(_lazyCorLibrary == null);
Debug.Assert(_lazyPhpCorLibrary == null);
//
var externalRefs = CorLibReferences.SelectMany(reference => compilation.Options.MetadataReferenceResolver.ResolveReference(reference, null, new MetadataReferenceProperties()))
.Concat(compilation.ExternalReferences).AsImmutable();
var assemblies = new List<AssemblySymbol>(externalRefs.Length);
var referencesMap = new Dictionary<MetadataReference, IAssemblySymbol>();
var metadataMap = new Dictionary<IAssemblySymbol, MetadataReference>();
var assembliesMap = new Dictionary<AssemblyIdentity, PEAssemblySymbol>();
var refmodules = new List<PEModuleSymbol>();
foreach (PortableExecutableReference pe in externalRefs)
{
var symbol = PEAssemblySymbol.Create(pe);
if (symbol != null)
{
assemblies.Add(symbol);
referencesMap[pe] = symbol;
metadataMap[symbol] = pe;
if (_lazyCorLibrary == null && symbol.IsCorLibrary)
_lazyCorLibrary = symbol;
if (_lazyPhpCorLibrary == null && symbol.IsPchpCorLibrary)
_lazyPhpCorLibrary = symbol;
// cache bound assembly symbol
_assembliesMap.Add(symbol.Identity, symbol);
// list of modules to initialize later
refmodules.AddRange(symbol.Modules.Cast<PEModuleSymbol>());
}
else
{
throw new Exception($"symbol '{pe.FilePath}' could not be created!");
}
}
//
_lazyExplicitReferences = externalRefs;
_lazyImplicitReferences = ImmutableArray<MetadataReference>.Empty;
_metadataMap = metadataMap.ToImmutableDictionary();
_referencesMap = referencesMap.ToImmutableDictionary();
//
var assembly = new SourceAssemblySymbol(compilation, compilation.Options.ModuleName, compilation.Options.ModuleName);
assembly.SetCorLibrary(_lazyCorLibrary);
compilation._lazyAssemblySymbol = assembly;
assembly.SourceModule.SetReferences(new ModuleReferences<AssemblySymbol>(
assemblies.Select(x => x.Identity).AsImmutable(),
assemblies.AsImmutable(),
ImmutableArray<UnifiedAssembly<AssemblySymbol>>.Empty), assembly);
assemblies.ForEach(ass => ass.SetCorLibrary(_lazyCorLibrary));
// recursively initialize references of referenced modules
SetReferencesOfReferencedModules(compilation.Options.MetadataReferenceResolver, refmodules);
// set cor types for this compilation
if (_lazyPhpCorLibrary == null) throw new DllNotFoundException("Peachpie.Runtime not found");
if (_lazyCorLibrary == null) throw new DllNotFoundException("A corlib not found");
compilation.CoreTypes.Update(_lazyPhpCorLibrary);
compilation.CoreTypes.Update(_lazyCorLibrary);
}
private static void CheckIfCommasAreAtTheSameLineAsThePreviousParameter(SyntaxNodeAnalysisContext context, SyntaxNodeOrTokenList nodeOrTokenList)
{
SyntaxNode previousNode = null;
// If index is even we expecting parameter syntax node, otherwise we expecting comma token.
for (int index = 0, count = nodeOrTokenList.Count; index < count; ++index)
{
SyntaxNodeOrToken nodeOrToken = nodeOrTokenList[index];
if (index % 2 == 0)
{
// We expecting node here
if (nodeOrToken.IsToken)
{
return;
}
previousNode = nodeOrToken.AsNode();
}
else
{
// We expecting token here
if (nodeOrToken.IsNode)
{
return;
}
if (previousNode.GetEndLine() < nodeOrToken.GetLineSpan().StartLinePosition.Line)
{
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove,
[OpenCloseSpacingCodeFixProvider.LayoutKey] = OpenCloseSpacingCodeFixProvider.LayoutPreserve
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, nodeOrToken.GetLocation(), properties.ToImmutableDictionary()));
}
}
}
}
private ImmutableDictionary<string, ImmutableList<LinkSourceInfo>> GetFileLinkSource(FileAndType ft, HtmlDocument doc)
{
var fileLinkSources = new Dictionary<string, List<LinkSourceInfo>>();
foreach (var pair in (from n in doc.DocumentNode.Descendants()
where !string.Equals(n.Name, "xref", StringComparison.OrdinalIgnoreCase)
from attr in n.Attributes
where string.Equals(attr.Name, "src", StringComparison.OrdinalIgnoreCase) ||
string.Equals(attr.Name, "href", StringComparison.OrdinalIgnoreCase)
where !string.IsNullOrWhiteSpace(attr.Value)
select new { Node = n, Attr = attr }).ToList())
{
string anchor = null;
var link = pair.Attr;
string linkFile = link.Value;
var index = linkFile.IndexOfAny(UriFragmentOrQueryString);
if (index != -1)
{
anchor = linkFile.Substring(index);
linkFile = linkFile.Remove(index);
}
if (TypeForwardedToRelativePath.IsRelativePath(linkFile))
{
var path = (TypeForwardedToRelativePath)ft.File + (TypeForwardedToRelativePath)linkFile;
string file = path.GetPathFromWorkingFolder().UrlDecode();
if (SourceFiles.ContainsKey(file))
{
link.Value = file;
if (!string.IsNullOrEmpty(anchor) &&
string.Equals(link.Name, "href", StringComparison.OrdinalIgnoreCase))
{
pair.Node.SetAttributeValue("anchor", anchor);
}
}
List<LinkSourceInfo> sources;
if (!fileLinkSources.TryGetValue(file, out sources))
{
sources = new List<LinkSourceInfo>();
fileLinkSources[file] = sources;
}
sources.Add(new LinkSourceInfo
{
Target = file,
Anchor = anchor,
SourceFile = pair.Node.GetAttributeValue("sourceFile", null),
LineNumber = pair.Node.GetAttributeValue("sourceStartLineNumber", 0),
});
}
}
return fileLinkSources.ToImmutableDictionary(x => x.Key, x => x.Value.ToImmutableList());
}
public AuthorizationManager(IAuthorizationConfiguration authorizationConfiguration) {
defaultAuthorizer = authorizationConfiguration.DefaultAuthorizer;
if (defaultAuthorizer == null) {
throw new InitialisationException("Default Authorizer cannot be null");
}
var isVisibleDict = new Dictionary<Type, Func<object, IPrincipal, object, string, bool>>() {
{defaultAuthorizer, DelegateUtils.CreateTypeAuthorizerDelegate(defaultAuthorizer.GetMethod("IsVisible"))}
};
var isEditableDict = new Dictionary<Type, Func<object, IPrincipal, object, string, bool>>() {
{defaultAuthorizer, DelegateUtils.CreateTypeAuthorizerDelegate(defaultAuthorizer.GetMethod("IsEditable"))}
};
if (authorizationConfiguration.NamespaceAuthorizers.Any()) {
namespaceAuthorizers = authorizationConfiguration.NamespaceAuthorizers.OrderByDescending(x => x.Key.Length).ToImmutableDictionary();
}
if (authorizationConfiguration.TypeAuthorizers.Any()) {
if (authorizationConfiguration.TypeAuthorizers.Values.Any(t => typeof(ITypeAuthorizer<object>).IsAssignableFrom(t))) {
throw new InitialisationException("Only Default Authorizer can be ITypeAuthorizer<object>");
}
typeAuthorizers = authorizationConfiguration.TypeAuthorizers.ToImmutableDictionary();
isVisibleDelegates = isVisibleDict.Union(authorizationConfiguration.TypeAuthorizers.Values.ToDictionary(type => type, type => DelegateUtils.CreateTypeAuthorizerDelegate(type.GetMethod("IsVisible")))).ToImmutableDictionary();
isEditableDelegates = isEditableDict.Union(authorizationConfiguration.TypeAuthorizers.Values.ToDictionary(type => type, type => DelegateUtils.CreateTypeAuthorizerDelegate(type.GetMethod("IsEditable")))).ToImmutableDictionary();
} else { // default authorizer must be the only TypeAuthorizer
isVisibleDelegates = isVisibleDict.ToImmutableDictionary();
isEditableDelegates = isEditableDict.ToImmutableDictionary();
}
}
internal static async Task<ImmutableArray<CodeFixEquivalenceGroup>> CreateAsync(CodeFixProvider codeFixProvider, ImmutableDictionary<ProjectId, ImmutableArray<Diagnostic>> allDiagnostics, Solution solution, CancellationToken cancellationToken)
{
var fixAllProvider = codeFixProvider.GetFixAllProvider();
if (fixAllProvider == null)
{
return ImmutableArray.Create<CodeFixEquivalenceGroup>();
}
Dictionary<ProjectId, Dictionary<string, List<Diagnostic>>> relevantDocumentDiagnostics =
new Dictionary<ProjectId, Dictionary<string, List<Diagnostic>>>();
Dictionary<ProjectId, List<Diagnostic>> relevantProjectDiagnostics =
new Dictionary<ProjectId, List<Diagnostic>>();
foreach (var projectDiagnostics in allDiagnostics)
{
foreach (var diagnostic in projectDiagnostics.Value)
{
if (!codeFixProvider.FixableDiagnosticIds.Contains(diagnostic.Id))
{
continue;
}
if (diagnostic.Location.IsInSource)
{
string sourcePath = diagnostic.Location.GetLineSpan().Path;
Dictionary<string, List<Diagnostic>> projectDocumentDiagnostics;
if (!relevantDocumentDiagnostics.TryGetValue(projectDiagnostics.Key, out projectDocumentDiagnostics))
{
projectDocumentDiagnostics = new Dictionary<string, List<Diagnostic>>();
relevantDocumentDiagnostics.Add(projectDiagnostics.Key, projectDocumentDiagnostics);
}
List<Diagnostic> diagnosticsInFile;
if (!projectDocumentDiagnostics.TryGetValue(sourcePath, out diagnosticsInFile))
{
diagnosticsInFile = new List<Diagnostic>();
projectDocumentDiagnostics.Add(sourcePath, diagnosticsInFile);
}
diagnosticsInFile.Add(diagnostic);
}
else
{
List<Diagnostic> diagnosticsInProject;
if (!relevantProjectDiagnostics.TryGetValue(projectDiagnostics.Key, out diagnosticsInProject))
{
diagnosticsInProject = new List<Diagnostic>();
relevantProjectDiagnostics.Add(projectDiagnostics.Key, diagnosticsInProject);
}
diagnosticsInProject.Add(diagnostic);
}
}
}
ImmutableDictionary<ProjectId, ImmutableDictionary<string, ImmutableArray<Diagnostic>>> documentDiagnosticsToFix =
relevantDocumentDiagnostics.ToImmutableDictionary(i => i.Key, i => i.Value.ToImmutableDictionary(j => j.Key, j => j.Value.ToImmutableArray(), StringComparer.OrdinalIgnoreCase));
ImmutableDictionary<ProjectId, ImmutableArray<Diagnostic>> projectDiagnosticsToFix =
relevantProjectDiagnostics.ToImmutableDictionary(i => i.Key, i => i.Value.ToImmutableArray());
HashSet<string> equivalenceKeys = new HashSet<string>();
foreach (var diagnostic in relevantDocumentDiagnostics.Values.SelectMany(i => i.Values).SelectMany(i => i).Concat(relevantProjectDiagnostics.Values.SelectMany(i => i)))
{
foreach (var codeAction in await GetFixesAsync(solution, codeFixProvider, diagnostic, cancellationToken).ConfigureAwait(false))
{
equivalenceKeys.Add(codeAction.EquivalenceKey);
}
}
List<CodeFixEquivalenceGroup> groups = new List<CodeFixEquivalenceGroup>();
foreach (var equivalenceKey in equivalenceKeys)
{
groups.Add(new CodeFixEquivalenceGroup(equivalenceKey, solution, fixAllProvider, codeFixProvider, documentDiagnosticsToFix, projectDiagnosticsToFix));
}
return groups.ToImmutableArray();
}
private static void HandleGreaterThanToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
{
if (token.IsMissing)
{
return;
}
switch (token.Parent.Kind())
{
case SyntaxKind.TypeArgumentList:
case SyntaxKind.TypeParameterList:
break;
default:
// not a generic bracket
return;
}
bool firstInLine = token.IsFirstInLine();
bool lastInLine = token.IsLastInLine();
bool precededBySpace = firstInLine || token.IsPrecededByWhitespace();
bool followedBySpace = token.IsFollowedByWhitespace();
bool allowTrailingNoSpace;
bool allowTrailingSpace;
if (!lastInLine)
{
SyntaxToken nextToken = token.GetNextToken();
switch (nextToken.Kind())
{
case SyntaxKind.OpenParenToken:
// DotToken isn't listed above, but it's required for reasonable member access formatting
case SyntaxKind.DotToken:
// CommaToken isn't listed above, but it's required for reasonable nested generic type arguments formatting
case SyntaxKind.CommaToken:
// OpenBracketToken isn't listed above, but it's required for reasonable array type formatting
case SyntaxKind.OpenBracketToken:
// SemicolonToken isn't listed above, but it's required for reasonable using alias declaration formatting
case SyntaxKind.SemicolonToken:
allowTrailingNoSpace = true;
allowTrailingSpace = false;
break;
case SyntaxKind.CloseParenToken:
case SyntaxKind.GreaterThanToken:
allowTrailingNoSpace = true;
allowTrailingSpace = true;
break;
case SyntaxKind.QuestionToken:
allowTrailingNoSpace = nextToken.Parent.IsKind(SyntaxKind.NullableType);
allowTrailingSpace = true;
break;
default:
allowTrailingNoSpace = false;
allowTrailingSpace = true;
break;
}
}
else
{
allowTrailingNoSpace = true;
allowTrailingSpace = true;
}
if (!firstInLine && precededBySpace)
{
// Closing generic bracket must{ not} be {preceded} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "preceded"));
}
if (!lastInLine)
{
if (!allowTrailingNoSpace && !followedBySpace)
{
// Closing generic bracket must{} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), string.Empty, "followed"));
}
else if (!allowTrailingSpace && followedBySpace)
{
// Closing generic bracket must{ not} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "followed"));
}
}
}
private static DiagnosticAnalyzerService CreateDiagnosticAnalyzerService(Dictionary<string, DiagnosticAnalyzer[]> analyzerMap)
{
return analyzerMap == null || analyzerMap.Count == 0
? new TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap())
: new TestDiagnosticAnalyzerService(analyzerMap.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value.ToImmutableArray()));
}
private static ImmutableDictionary<string, ImmutableList<CodeFixProvider>> GetAllCodeFixers()
{
Assembly assembly = typeof(StyleCop.Analyzers.SpacingRules.SA1027CodeFixProvider).Assembly;
var codeFixProviderType = typeof(CodeFixProvider);
Dictionary<string, ImmutableList<CodeFixProvider>> providers = new Dictionary<string, ImmutableList<CodeFixProvider>>();
foreach (var type in assembly.GetTypes())
{
if (type.IsSubclassOf(codeFixProviderType) && !type.IsAbstract)
{
var codeFixProvider = (CodeFixProvider)Activator.CreateInstance(type);
foreach (var diagnosticId in codeFixProvider.FixableDiagnosticIds)
{
providers.AddToInnerList(diagnosticId, codeFixProvider);
}
}
}
return providers.ToImmutableDictionary();
}
private static void HandleCloseBracketToken(SyntaxTreeAnalysisContext context, SyntaxToken token)
{
if (token.IsMissing)
{
return;
}
// attribute brackets are handled separately
if (token.Parent.IsKind(SyntaxKind.AttributeList))
{
return;
}
bool firstInLine = token.IsFirstInLine();
bool precededBySpace = firstInLine || token.IsPrecededByWhitespace();
bool followedBySpace = token.IsFollowedByWhitespace();
bool lastInLine = token.IsLastInLine();
bool precedesSpecialCharacter;
// Tests for this rule have a lot of exclusions which are supposed to be caught by other rules
bool suppressFollowingSpaceError = true;
if (!lastInLine)
{
SyntaxToken nextToken = token.GetNextToken();
switch (nextToken.Kind())
{
case SyntaxKind.CloseBracketToken:
case SyntaxKind.OpenParenToken:
case SyntaxKind.CommaToken:
case SyntaxKind.SemicolonToken:
// TODO: "certain types of operator symbols"
case SyntaxKind.DotToken:
case SyntaxKind.OpenBracketToken:
case SyntaxKind.CloseParenToken:
precedesSpecialCharacter = true;
break;
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
precedesSpecialCharacter = true;
suppressFollowingSpaceError = false;
break;
case SyntaxKind.GreaterThanToken:
precedesSpecialCharacter = nextToken.Parent.IsKind(SyntaxKind.TypeArgumentList);
break;
case SyntaxKind.QuestionToken:
precedesSpecialCharacter = nextToken.Parent.IsKind(SyntaxKind.ConditionalAccessExpression);
break;
case SyntaxKind.CloseBraceToken:
precedesSpecialCharacter = nextToken.Parent is InterpolationSyntax;
break;
default:
precedesSpecialCharacter = false;
break;
}
}
else
{
precedesSpecialCharacter = false;
}
if (!firstInLine && precededBySpace)
{
// Closing square bracket must{ not} be {preceded} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationPreceding,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "preceded"));
}
if (!lastInLine)
{
if (!precedesSpecialCharacter && !followedBySpace)
{
// Closing square bracket must{} be {followed} by a space.
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionInsert
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), string.Empty, "followed"));
}
else if (precedesSpecialCharacter && followedBySpace && !suppressFollowingSpaceError)
{
// Closing square brackets must {not} be {followed} by a space
var properties = new Dictionary<string, string>
{
[OpenCloseSpacingCodeFixProvider.LocationKey] = OpenCloseSpacingCodeFixProvider.LocationFollowing,
[OpenCloseSpacingCodeFixProvider.ActionKey] = OpenCloseSpacingCodeFixProvider.ActionRemove
};
context.ReportDiagnostic(Diagnostic.Create(Descriptor, token.GetLocation(), properties.ToImmutableDictionary(), " not", "followed"));
}
}
}
/// <summary>
/// Returns a list of all analyzer diagnostics inside the specific project. This is an asynchronous operation.
/// </summary>
/// <param name="analyzers">The list of analyzers that should be used</param>
/// <param name="project">The project that should be analyzed</param>
/// <param name="force"><see langword="true"/> to force the analyzers to be enabled; otherwise,
/// <see langword="false"/> to use the behavior configured for the specified <paramref name="project"/>.</param>
/// <param name="cancellationToken">The cancellation token that the task will observe.</param>
/// <returns>A list of diagnostics inside the project</returns>
private static async Task<ImmutableArray<Diagnostic>> GetProjectAnalyzerDiagnosticsAsync(ImmutableArray<DiagnosticAnalyzer> analyzers, Project project, bool force, CancellationToken cancellationToken)
{
var supportedDiagnosticsSpecificOptions = new Dictionary<string, ReportDiagnostic>();
if (force)
{
foreach (var analyzer in analyzers)
{
foreach (var diagnostic in analyzer.SupportedDiagnostics)
{
// make sure the analyzers we are testing are enabled
supportedDiagnosticsSpecificOptions[diagnostic.Id] = ReportDiagnostic.Default;
}
}
}
// Report exceptions during the analysis process as errors
supportedDiagnosticsSpecificOptions.Add("AD0001", ReportDiagnostic.Error);
// update the project compilation options
var modifiedSpecificDiagnosticOptions = supportedDiagnosticsSpecificOptions.ToImmutableDictionary().SetItems(project.CompilationOptions.SpecificDiagnosticOptions);
var modifiedCompilationOptions = project.CompilationOptions.WithSpecificDiagnosticOptions(modifiedSpecificDiagnosticOptions);
var processedProject = project.WithCompilationOptions(modifiedCompilationOptions);
Compilation compilation = await processedProject.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
CompilationWithAnalyzers compilationWithAnalyzers = compilation.WithAnalyzers(analyzers, cancellationToken: cancellationToken);
var diagnostics = await FixAllContextHelper.GetAllDiagnosticsAsync(compilation, compilationWithAnalyzers, analyzers, project.Documents, true, cancellationToken).ConfigureAwait(false);
return diagnostics;
}
private static void InitializeWellKnownSystemNamespaceTable()
{
if (s_wellKnownSystemNamespaceTable == null)
{
lock (s_lock)
{
if (s_wellKnownSystemNamespaceTable == null)
{
#region List of Well known System Namespaces
var wellKnownSystemNamespaces = new List<string>
{
"Microsoft.CSharp",
"Microsoft.SqlServer.Server",
"Microsoft.VisualBasic",
"Microsoft.Win32",
"Microsoft.Win32.SafeHandles",
"System",
"System.CodeDom",
"System.CodeDom.Compiler",
"System.Collections",
"System.Collections.Generic",
"System.Collections.ObjectModel",
"System.Collections.Specialized",
"System.ComponentModel",
"System.ComponentModel.Design",
"System.ComponentModel.Design.Serialization",
"System.Configuration",
"System.Configuration.Assemblies",
"System.Data",
"System.Data.Common",
"System.Data.Odbc",
"System.Data.OleDb",
"System.Data.Sql",
"System.Data.SqlClient",
"System.Data.SqlTypes",
"System.Deployment.Internal",
"System.Diagnostics",
"System.Diagnostics.CodeAnalysis",
"System.Diagnostics.SymbolStore",
"System.Drawing",
"System.Drawing.Design",
"System.Drawing.Drawing2D",
"System.Drawing.Imaging",
"System.Drawing.Printing",
"System.Drawing.Text",
"System.Globalization",
"System.IO",
"System.IO.Compression",
"System.IO.IsolatedStorage",
"System.IO.Ports",
"System.Media",
"System.Net",
"System.Net.Cache",
"System.Net.Configuration",
"System.Net.Mail",
"System.Net.Mime",
"System.Net.NetworkInformation",
"System.Net.Security",
"System.Net.Sockets",
"System.Reflection",
"System.Reflection.Emit",
"System.Resources",
"System.Runtime",
"System.Runtime.CompilerServices",
"System.Runtime.ConstrainedExecution",
"System.Runtime.Hosting",
"System.Runtime.InteropServices",
"System.Runtime.InteropServices.ComTypes",
"System.Runtime.InteropServices.Expando",
"System.Runtime.Remoting",
"System.Runtime.Remoting.Activation",
"System.Runtime.Remoting.Channels",
"System.Runtime.Remoting.Contexts",
"System.Runtime.Remoting.Lifetime",
"System.Runtime.Remoting.Messaging",
"System.Runtime.Remoting.Metadata",
"System.Runtime.Remoting.Metadata.W3cXsd2001",
"System.Runtime.Remoting.Proxies",
"System.Runtime.Remoting.Services",
"System.Runtime.Serialization",
"System.Runtime.Serialization.Formatters",
"System.Runtime.Serialization.Formatters.Binary",
"System.Runtime.Versioning",
"System.Security",
"System.Security.AccessControl",
"System.Security.Authentication",
"System.Security.Cryptography",
"System.Security.Cryptography.X509Certificates",
"System.Security.Permissions",
"System.Security.Policy",
"System.Security.Principal",
"System.Text",
"System.Text.RegularExpressions",
"System.Threading",
"System.Timers",
"System.Web",
"System.Web.Caching",
"System.Web.Compilation",
"System.Web.Configuration",
"System.Web.Configuration.Internal",
"System.Web.Handlers",
"System.Web.Hosting",
"System.Web.Mail",
"System.Web.Management",
"System.Web.Profile",
"System.Web.Security",
"System.Web.SessionState",
"System.Web.UI",
"System.Web.UI.Adapters",
"System.Web.UI.HtmlControls",
"System.Web.UI.WebControls",
"System.Web.UI.WebControls.Adapters",
"System.Web.UI.WebControls.WebParts",
"System.Web.Util",
"System.Windows.Forms",
"System.Windows.Forms.ComponentModel.Com2Interop",
"System.Windows.Forms.Design",
"System.Windows.Forms.Layout",
"System.Windows.Forms.PropertyGridInternal",
"System.Windows.Forms.VisualStyles",
"System.Xml",
"System.Xml.Schema",
"System.Xml.Serialization",
"System.Xml.Serialization.Advanced",
"System.Xml.Serialization.Configuration",
"System.Xml.XPath",
"System.Xml.Xsl"
};
#endregion
var wellKnownSystemNamespaceTable = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
UpdateNamespaceTable(wellKnownSystemNamespaceTable, wellKnownSystemNamespaces);
s_wellKnownSystemNamespaceTable = wellKnownSystemNamespaceTable.ToImmutableDictionary();
}
}
}
}
