private DiagnosticCollector <D> DiagnosticCollectorFor <D>()
{
var collector = new DiagnosticCollector <D>();
Db().Configure().Diagnostic().AddListener(collector);
return(collector);
}
private static void AnalyzeAccessorMethod([CanBeNull] IMethodSymbol accessorMethod,
[NotNull] DiagnosticCollector collector, SymbolAnalysisContext context)
{
if (accessorMethod == null || ShouldSkip(accessorMethod))
{
return;
}
InnerAnalyzeMethod(context.Wrap(accessorMethod), collector);
}
private void AssertQueryIsOptimized(Action <IObjectContainer> action)
{
DiagnosticCollector <NativeQueryNotOptimized> collector = new DiagnosticCollector <NativeQueryNotOptimized>();
using (IObjectContainer container = Db4oEmbedded.OpenFile(NewConfiguration(collector), Path.GetTempFileName()))
{
action(container);
}
Assert.AreEqual(0, collector.Diagnostics.Count);
}
public void TestIndexedQuery()
{
DiagnosticCollector <LoadedFromClassIndex> collector = DiagnosticCollectorFor <LoadedFromClassIndex>();
ValueTypeHolder expected = ObjectsToOperateOn()[0];
ValueTypeHolder actual = RetrieveHolderWithValue(expected.Value);
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual);
Assert.AreEqual(0, collector.Diagnostics.Count, WithTypeName("Query should go through {0} indexes"));
}
private static void AnalyzeProperty(SymbolAnalysisContext context)
{
var property = (IPropertySymbol)context.Symbol;
using var collector = new DiagnosticCollector(context.ReportDiagnostic);
AnalyzeAccessorMethod(property.GetMethod, collector, context);
AnalyzeAccessorMethod(property.SetMethod, collector, context);
FilterDuplicateLocations(collector.Diagnostics);
}
private static void AnalyzeEvent(SymbolAnalysisContext context)
{
var @event = (IEventSymbol)context.Symbol;
using var collector = new DiagnosticCollector(context.ReportDiagnostic);
AnalyzeAccessorMethod(@event.AddMethod, collector, context);
AnalyzeAccessorMethod(@event.RemoveMethod, collector, context);
FilterDuplicateLocations(collector.Diagnostics);
}
private static void InnerAnalyzeMethod(BaseAnalysisContext <IMethodSymbol> context,
[NotNull] DiagnosticCollector collector)
{
SyntaxNode bodySyntax = context.Target.TryGetBodySyntaxForMethod(context.CancellationToken);
if (bodySyntax == null)
{
return;
}
AnalyzeParametersInMethod(context.WithTarget(context.Target.Parameters), bodySyntax, collector);
}
private static void AnalyzeMethod(SymbolAnalysisContext context)
{
var method = (IMethodSymbol)context.Symbol;
if (ShouldSkip(method) || method.IsPropertyOrEventAccessor())
{
return;
}
using var collector = new DiagnosticCollector(context.ReportDiagnostic);
InnerAnalyzeMethod(context.Wrap(method), collector);
}
private static void AnalyzeAnonymousFunction(OperationAnalysisContext context)
{
var anonymousFunction = (IAnonymousFunctionOperation)context.Operation;
if (ShouldSkip(anonymousFunction.Symbol))
{
return;
}
using var collector = new DiagnosticCollector(context.ReportDiagnostic);
InnerAnalyzeMethod(context.Wrap(anonymousFunction.Symbol), collector);
}
private static void AnalyzeLocalFunction(OperationAnalysisContext context)
{
var localFunction = (ILocalFunctionOperation)context.Operation;
if (ShouldSkip(localFunction.Symbol))
{
return;
}
using (var collector = new DiagnosticCollector(context.ReportDiagnostic))
{
InnerAnalyzeMethod(context.Wrap(localFunction.Symbol), collector);
}
}
private T Compile <T>(string className, string source, CompilationListener <T> listener)
{
JavaCompiler systemCompiler = ToolProvider.SystemJavaCompiler;
JavaFileManager manager = new InMemFileManager();
DiagnosticCollector <JavaFileObject> diagnosticsCollector = new DiagnosticCollector <JavaFileObject>();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Iterable<? extends javax.tools.JavaFileObject> sources = java.util.Collections.singletonList(new InMemSource(className, source));
IEnumerable <JavaFileObject> sources = Collections.singletonList(new InMemSource(className, source));
JavaCompiler.CompilationTask task = systemCompiler.getTask(null, manager, diagnosticsCollector, null, null, sources);
bool?success = task.call();
return(listener.Compiled(success, manager, diagnosticsCollector.Diagnostics));
}
public void TestDelete()
{
DiagnosticCollector <DeletionFailed> diagnosticCollector = DiagnosticCollectorFor <DeletionFailed>();
IQuery query = NewQuery(typeof(ValueTypeHolder));
IObjectSet result = query.Execute();
while (result.HasNext())
{
ValueTypeHolder item = (ValueTypeHolder)result.Next();
Db().Delete(item);
}
Assert.IsTrue(diagnosticCollector.Empty, diagnosticCollector.ToString());
}
private static void AnalyzeStructParameters(BaseAnalysisContext <ICollection <IParameterSymbol> > context,
[NotNull] SyntaxNode bodySyntax, [NotNull] DiagnosticCollector collector)
{
// A user-defined struct can reassign its 'this' parameter on invocation. That's why the compiler dataflow
// analysis reports all access as writes. Because that's not very practical, we run our own assignment analysis.
SemanticModel model = context.Compilation.GetSemanticModel(bodySyntax.SyntaxTree);
IOperation bodyOperation = model.GetOperation(bodySyntax);
if (bodyOperation == null || bodyOperation.HasErrors(context.Compilation, context.CancellationToken))
{
return;
}
CollectAssignedStructParameters(context.Target, bodyOperation, collector);
}
public SolutionTraceSettingsContext(ISolutionBrowser solutionBrowser = null)
{
this.solutionBrowser = solutionBrowser;
ProjectsInSolution = FindProjects();
ManifestsInSolution = ThreadingExtensions.CreateAsyncLazy(FindManifests);
manifestCache = new FileLruCache <EventManifest>(
10, path => {
var diags = new DiagnosticCollector();
var parser = EventManifestParser.CreateWithWinmeta(diags);
var manifest = parser.ParseManifest(path);
if (manifest == null || diags.Diagnostics.Count != 0)
{
throw new Exception(
string.Join("\r\n", diags.Diagnostics.Select(x => x.Message)));
}
return(manifest);
});
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public Iterable<? extends org.neo4j.codegen.ByteCodes> compile(java.util.List<JavaSourceFile> sourceFiles, ClassLoader loader) throws org.neo4j.codegen.CompilationFailureException
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
public override IEnumerable <ByteCodes> Compile(IList <JavaSourceFile> sourceFiles, ClassLoader loader)
{
DiagnosticCollector <JavaFileObject> diagnostics = new DiagnosticCollector <JavaFileObject>();
FileManager fileManager = new FileManager(_compiler.getStandardFileManager(diagnostics, _configuration.locale(), _configuration.charset()));
JavaCompiler.CompilationTask task = _compiler.getTask(_configuration.errorWriter(), fileManager, diagnostics, _configuration.options(), null, sourceFiles);
_configuration.processors(task);
if (task.call())
{
_configuration.warningsHandler().handle(diagnostics.Diagnostics);
return(fileManager.Bytecodes());
}
else
{
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") java.util.List<javax.tools.Diagnostic<?>> issues = (java.util.List) diagnostics.getDiagnostics();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
IList <Diagnostic <object> > issues = (System.Collections.IList)diagnostics.Diagnostics;
throw new CompilationFailureException(issues);
}
}
protected override void Configure(IConfiguration config)
{
diagnosticCollector = new DiagnosticCollector<NativeQueryNotOptimized>();
config.Diagnostic().AddListener(diagnosticCollector);
}
private static void AnalyzeOrdinaryParameters(BaseAnalysisContext <ICollection <IParameterSymbol> > context,
[NotNull] SyntaxNode bodySyntax, [NotNull] DiagnosticCollector collector)
{
DataFlowAnalysis dataFlowAnalysis = TryAnalyzeDataFlow(bodySyntax, context.Compilation);
if (dataFlowAnalysis == null)
{
return;
}
foreach (IParameterSymbol parameter in context.Target)
{
if (dataFlowAnalysis.WrittenInside.Contains(parameter))
{
collector.Add(Diagnostic.Create(Rule, parameter.Locations[0], parameter.Name));
}
}
}
private static void AnalyzeParametersInMethod(BaseAnalysisContext <ImmutableArray <IParameterSymbol> > context,
[NotNull] SyntaxNode bodySyntax, [NotNull] DiagnosticCollector collector)
{
IGrouping <bool, IParameterSymbol>[] parameterGrouping = context.Target
.Where(parameter => parameter.RefKind == RefKind.None && !parameter.IsSynthesized()).GroupBy(IsUserDefinedStruct)
.ToArray();
ICollection <IParameterSymbol> ordinaryParameters =
parameterGrouping.Where(group => !group.Key).SelectMany(group => group).ToArray();
if (ordinaryParameters.Any())
{
AnalyzeOrdinaryParameters(context.WithTarget(ordinaryParameters), bodySyntax, collector);
}
ICollection <IParameterSymbol> structParameters =
parameterGrouping.Where(group => group.Key).SelectMany(group => group).ToArray();
if (structParameters.Any())
{
AnalyzeStructParameters(context.WithTarget(structParameters), bodySyntax, collector);
}
}
private static void CollectAssignedStructParameters([NotNull][ItemNotNull] ICollection <IParameterSymbol> parameters,
[NotNull] IOperation bodyOperation, [NotNull] DiagnosticCollector collector)
{
var walker = new AssignmentWalker(parameters);
walker.Visit(bodyOperation);
foreach (IParameterSymbol parameter in walker.ParametersAssigned)
{
collector.Add(Diagnostic.Create(Rule, parameter.Locations[0], parameter.Name));
}
}
protected override void Configure(IConfiguration config)
{
diagnosticCollector = new DiagnosticCollector <NativeQueryNotOptimized>();
config.Diagnostic().AddListener(diagnosticCollector);
}
