public static void CreateAndRegisterActions(CompilationStartAnalysisContext compilationStartContext)
{
compilationStartContext.RegisterSymbolStartAction(symbolStartContext =>
{
// We report diagnostic only if these requirements are met:
// 1. The type is struct
// 2. Struct contains at least one 'readonly' field
// 3. Struct contains assignment to 'this' outside the scope of constructor
var namedTypeSymbol = (INamedTypeSymbol)symbolStartContext.Symbol;
// We are only interested in struct declarations
if (namedTypeSymbol.TypeKind != TypeKind.Struct)
{
return;
}
//We check if struct contains any 'readonly' fields
if (!HasReadonlyField(namedTypeSymbol))
{
return;
}
var symbolAnalyzer = new SymbolAnalyzer(namedTypeSymbol);
symbolAnalyzer.RegisterActions(symbolStartContext);
}, SymbolKind.NamedType);
}
public static void OnSymbolStart(SymbolStartAnalysisContext symbolStartContext, DisposeAnalysisHelper disposeAnalysisHelper)
{
// We only want to analyze types which are disposable (implement System.IDisposable directly or indirectly)
// and have at least one disposable field.
var namedType = (INamedTypeSymbol)symbolStartContext.Symbol;
if (!namedType.IsDisposable(disposeAnalysisHelper.IDisposableType))
{
return;
}
var disposableFields = disposeAnalysisHelper.GetDisposableFields(namedType);
if (disposableFields.IsEmpty)
{
return;
}
var analyzer = new SymbolAnalyzer(disposableFields, disposeAnalysisHelper);
// Register an operation block action to analyze disposable assignments and dispose invocations for fields.
symbolStartContext.RegisterOperationBlockStartAction(analyzer.OnOperationBlockStart);
// Register symbol end action for containing type to report non-disposed fields.
// We report fields that have disposable type (implement System.IDisposable directly or indirectly)
// and were assigned a disposable object within this containing type, but were not disposed in
// containing type's Dispose method.
symbolStartContext.RegisterSymbolEndAction(analyzer.OnSymbolEnd);
}
public void SymbolAnalyzer__ReturnsCorrectCount(string line, bool twoCount, bool threeCount)
{
var analyzer = new SymbolAnalyzer();
var counts = analyzer.Analyze(line);
Assert.Equal((twoCount, threeCount), counts);
}
//static char[] GetSymbolChars()
//{
// var chars = new List<char>(50000);
// for (var u = 0; u <= ushort.MaxValue; u++)
// {
// var ch = (char)u;
// if (IsDeniedCharacter(ch))
// continue;
// if (char.IsLetter(ch))
// chars.Add(ch);
// }
// return chars.ToArray();
//}
//static bool IsDeniedCharacter(char ch)
//{
// switch (ch)
// {
// case '\u180E':
// case '\u0600':
// case '\u00AD':
// return true;
// }
// return false;
//}
//static readonly char[] BaseNChars = GetSymbolChars();
public async Task <ProgramComposition> ProcessAsync([NotNull] ProgramComposition composition, [NotNull] MDKProjectProperties config)
{
if (composition == null)
{
throw new ArgumentNullException(nameof(composition));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
var analyzer = new SymbolAnalyzer();
var symbolDefinitions = analyzer.FindSymbols(composition, config).ToList();
symbolDefinitions.Sort((a, b) => a.SyntaxNode.FullSpan.Start);
var distinctSymbolNames = new HashSet <string>(symbolDefinitions
.Where(s => !s.IsProtected)
.Select(s => s.Symbol.Name)
.Distinct());
var symbolSrc = 0;
var minifiedSymbolNames = distinctSymbolNames
.ToDictionary(n => n, n => GenerateNewName(distinctSymbolNames, ref symbolSrc));
while (true)
{
SymbolDefinitionInfo definition = null;
string newName = null;
foreach (var symbolDefinition in symbolDefinitions)
{
if (symbolDefinition.IsProtected)
{
continue;
}
if (!minifiedSymbolNames.TryGetValue(symbolDefinition.Symbol.Name, out newName))
{
continue;
}
definition = symbolDefinition;
break;
}
if (definition == null)
{
break;
}
var document = composition.Document;
var documentId = document.Id;
var newSolution = await Renamer.RenameSymbolAsync(document.Project.Solution, definition.Symbol, newName, document.Project.Solution.Options);
composition = await composition.WithDocumentAsync(newSolution.GetDocument(documentId));
symbolDefinitions = analyzer.FindSymbols(composition, config).ToList();
symbolDefinitions.Sort((a, b) => a.SyntaxNode.FullSpan.Start);
}
return(composition);
}
protected override void InitializeWorker(AnalysisContext context)
{
context.RegisterCompilationStartAction(compilationContext =>
{
if (!DisposeAnalysisHelper.TryCreate(compilationContext.Compilation, out var disposeAnalysisHelper))
{
return;
}
// Register a symbol start action to analyze all named types.
compilationContext.RegisterSymbolStartAction(
symbolStartContext => SymbolAnalyzer.OnSymbolStart(symbolStartContext, disposeAnalysisHelper),
SymbolKind.NamedType);
});
}
public override void Initialize(AnalysisContext analysisContext)
{
analysisContext.EnableConcurrentExecution();
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(
(context) =>
{
INamedTypeSymbol iserializableTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationISerializable);
if (iserializableTypeSymbol == null)
{
return;
}
INamedTypeSymbol serializationInfoTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationSerializationInfo);
if (serializationInfoTypeSymbol == null)
{
return;
}
INamedTypeSymbol streamingContextTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationStreamingContext);
if (streamingContextTypeSymbol == null)
{
return;
}
INamedTypeSymbol serializableAttributeTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemSerializableAttribute);
if (serializableAttributeTypeSymbol == null)
{
return;
}
INamedTypeSymbol nonSerializedAttributeTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemNonSerializedAttribute);
if (nonSerializedAttributeTypeSymbol == null)
{
return;
}
var systemObjectSymbol = context.Compilation.GetSpecialType(SpecialType.System_Object);
var isNetStandardAssembly = systemObjectSymbol.ContainingAssembly.Name != "mscorlib";
var symbolAnalyzer = new SymbolAnalyzer(iserializableTypeSymbol, serializationInfoTypeSymbol, streamingContextTypeSymbol, serializableAttributeTypeSymbol, nonSerializedAttributeTypeSymbol, isNetStandardAssembly);
context.RegisterSymbolAction(symbolAnalyzer.AnalyzeSymbol, SymbolKind.NamedType);
});
}
public override void Initialize(AnalysisContext analysisContext)
{
analysisContext.EnableConcurrentExecution();
analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
analysisContext.RegisterCompilationStartAction(
(context) =>
{
INamedTypeSymbol iserializableTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationISerializable);
if (iserializableTypeSymbol == null)
{
return;
}
INamedTypeSymbol serializationInfoTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationSerializationInfo);
if (serializationInfoTypeSymbol == null)
{
return;
}
INamedTypeSymbol streamingContextTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationStreamingContext);
if (streamingContextTypeSymbol == null)
{
return;
}
INamedTypeSymbol serializableAttributeTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemSerializableAttribute);
if (serializableAttributeTypeSymbol == null)
{
return;
}
INamedTypeSymbol nonSerializedAttributeTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemNonSerializedAttribute);
if (nonSerializedAttributeTypeSymbol == null)
{
return;
}
var isNetStandardAssembly = context.Compilation.ReferencedAssemblyNames.Any(identity => string.Equals(identity.Name, "netstandard", StringComparison.OrdinalIgnoreCase));
var symbolAnalyzer = new SymbolAnalyzer(iserializableTypeSymbol, serializationInfoTypeSymbol, streamingContextTypeSymbol, serializableAttributeTypeSymbol, nonSerializedAttributeTypeSymbol, isNetStandardAssembly);
context.RegisterSymbolAction(symbolAnalyzer.AnalyzeSymbol, SymbolKind.NamedType);
});
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(
(context) =>
{
INamedTypeSymbol?iserializableTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationISerializable);
if (iserializableTypeSymbol == null)
{
return;
}
INamedTypeSymbol?serializationInfoTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationSerializationInfo);
if (serializationInfoTypeSymbol == null)
{
return;
}
INamedTypeSymbol?streamingContextTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeSerializationStreamingContext);
if (streamingContextTypeSymbol == null)
{
return;
}
INamedTypeSymbol?serializableAttributeTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemSerializableAttribute);
if (serializableAttributeTypeSymbol == null)
{
return;
}
INamedTypeSymbol?nonSerializedAttributeTypeSymbol = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemNonSerializedAttribute);
if (nonSerializedAttributeTypeSymbol == null)
{
return;
}
var isNetStandardAssembly = !context.Compilation.TargetsDotNetFramework();
var symbolAnalyzer = new SymbolAnalyzer(iserializableTypeSymbol, serializationInfoTypeSymbol, streamingContextTypeSymbol, serializableAttributeTypeSymbol, nonSerializedAttributeTypeSymbol, isNetStandardAssembly);
context.RegisterSymbolAction(symbolAnalyzer.AnalyzeSymbol, SymbolKind.NamedType);
});
}
protected override void InitializeWorker(AnalysisContext context)
{
context.RegisterCompilationStartAction(compilationStartContext
=> SymbolAnalyzer.CreateAndRegisterActions(compilationStartContext));
}
static SymbolAnalyzer()
{
instance = new SymbolAnalyzer();
}