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); }