private void AnalyzeForSingletonTakesCustomOrTransient( IDiagnosticReporter diagnosticReporter ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } foreach (var pair in this.Box.Groups.Shuffle()) { var group = pair.Value; foreach (var bindingExtender in group.BindingExtenders) { if (bindingExtender.BindingContainer.Scope.In(BindScopeEnum.Singleton)) { if (Box.TryGetChildren(bindingExtender.BindingContainer, true, out var cpairs)) { foreach (var cpair in cpairs) { var childExtender = cpair.BindingExtender; if (childExtender.BindingContainer.Scope.In(BindScopeEnum.Custom, BindScopeEnum.Transient)) { diagnosticReporter.ReportWarning( $"Singleton-{childExtender.BindingContainer.Scope} relationship has been found.", $"Searching for singleton-{childExtender.BindingContainer.Scope} relationship has been found: singleton parent [{bindingExtender.BindingContainer.TargetRepresentation}] takes {childExtender.BindingContainer.Scope} child [{childExtender.BindingContainer.TargetRepresentation}]." ); } } } } } } }
public EmbedderRewriter(SemanticModel model, EmbedderConfig config, IDiagnosticReporter reporter, CancellationToken cancellationToken) { this.model = model; this.config = config; this.reporter = reporter; this.cancellationToken = cancellationToken; }
/// <summary> /// Generated a code file from a RESX file. /// </summary> /// <param name="path">The path to the RESX file to generate from.</param> /// <param name="reporter">An object used to communicate diagnostics back to the caller.</param> /// <returns>The content of the generated code file.</returns> public string RunOnFile(string path, IDiagnosticReporter reporter) { using (var reader = new ResXResourceReader(path)) { return(GenerateCodeForResx(reader, reporter)); } }
public SourceValidation(IEnumerable <IGroupValidationProvider> groupValidationProviders, IEnumerable <ITypeValidationProvider> typeValidationProviders, ConditionAnalyzer conditions, IDiagnosticReporter diagnostics) { _groupProviders = groupValidationProviders; _typeProviders = typeValidationProviders; _conditionAnalyzer = conditions; _diagnostics = diagnostics; }
public SyntaxVerification(IGenerationStartupServices startupServices, IEnumerable <IGenerationStartup> startups, ISourceMetaAnalysis analysis, IDiagnosticReporter diagnostic) { _startupServices = startupServices; _analysis = analysis; _diagnostic = diagnostic; _startups = startups.ToList(); }
public CloudFormationJsonWriter(IFileManager fileManager, IDirectoryManager directoryManager, IJsonWriter jsonWriter, IDiagnosticReporter diagnosticReporter) { _fileManager = fileManager; _directoryManager = directoryManager; _jsonWriter = jsonWriter; _diagnosticReporter = diagnosticReporter; }
public ConventionalBindExpressionFactory( ITypeInfoContainer typeInfoContainer, ConstructorArgumentFromSyntaxExtractor extractor, ConstructorArgumentDetector constructorArgumentDetector, IDiagnosticReporter diagnosticReporter ) { if (typeInfoContainer is null) { throw new ArgumentNullException(nameof(typeInfoContainer)); } if (extractor is null) { throw new ArgumentNullException(nameof(extractor)); } if (constructorArgumentDetector is null) { throw new ArgumentNullException(nameof(constructorArgumentDetector)); } if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } _typeInfoContainer = typeInfoContainer; _extractor = extractor; _constructorArgumentDetector = constructorArgumentDetector; _diagnosticReporter = diagnosticReporter; }
/// <summary> /// Generated a code file from a RESX file. /// </summary> /// <param name="resxContent">The content of the RESX file to generate from.</param> /// <param name="reporter">An object used to communicate diagnostics back to the caller.</param> /// <returns>The content of the generated code file.</returns> public string RunOnContent(string resxContent, IDiagnosticReporter reporter) { using (var reader = ResXResourceReader.FromFileContents(resxContent)) { return(GenerateCodeForResx(reader, reporter)); } }
/// <summary> /// Analyze the built tree and raise diagnostics if needed. /// </summary> public void Analyze( IDiagnosticReporter diagnosticReporter ) { AnalyzeForCircularDependencies(diagnosticReporter); AnalyzeForMultipleUnconditionalChildExists(diagnosticReporter); AnalyzeForSingletonTakesCustomOrTransient(diagnosticReporter); }
public SourcebergHostBuilderBase(ITypeSymbolProvider symbolProvider, ISourceAddition sourceAddition, IDiagnosticReporter <THostBuilder> diagnosticReporter) { _source = sourceAddition; _reporter = diagnosticReporter; SymbolProvider = symbolProvider; Resolvable = symbolProvider.Source.GetAssemblySymbol(typeof(SourcebergAnalyzerAttribute).Assembly) is not null; }
public CycleChecker( IDiagnosticReporter reporter ) { if (reporter is null) { throw new ArgumentNullException(nameof(reporter)); } _reporter = reporter; }
/// <summary> /// Generates a code file from the given RESX reader. /// </summary> /// <param name="reader">The resx reader the generated class is based on.</param> /// <param name="reporter">An object used to communicate diagnostics back to the caller.</param> /// <returns>The content of the generated code file.</returns> private string GenerateCodeForResx(ResXResourceReader reader, IDiagnosticReporter reporter) { if (reporter == null) { reporter = new ConsoleReporter(); } ResourceTemplate template = BuildTemplate(reader, reporter); return(template.TransformText()); }
public DpdtInternalGenerator( IDiagnosticReporter diagnosticReporter ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } _diagnosticReporter = diagnosticReporter; }
public DpdtInternalGenerator( IDiagnosticReporter diagnosticReporter, bool doBeautify ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } _diagnosticReporter = diagnosticReporter; _doBeautify = doBeautify; }
public EmbeddingContext( CSharpCompilation compilation, CSharpParseOptions parseOptions, IDiagnosticReporter reporter, EmbedderConfig config, CancellationToken cancellationToken = default) { Compilation = compilation; ParseOptions = parseOptions; Reporter = reporter; Config = config; CancellationToken = cancellationToken; }
private void AnalyzeForCircularDependencies( IDiagnosticReporter diagnosticReporter ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } new CycleChecker( diagnosticReporter ) .CheckForCycles(Box); }
public EmbeddedLoader( CSharpCompilation compilation, CSharpParseOptions parseOptions, IDiagnosticReporter reporter, ExpandConfig config, CancellationToken cancellationToken = default) { this.reporter = reporter; this.compilation = compilation; this.ConcurrentBuild = compilation.Options.ConcurrentBuild; this.parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Diagnose); this.config = config; this.cancellationToken = cancellationToken; var embeddedDatas = new AssemblyMetadataResolver(compilation).GetEmbeddedSourceFiles(cancellationToken); container = new SourceFileContainer(WithCheck(embeddedDatas)); }
public TimedCycleChecker( IDiagnosticReporter diagnosticReporter, ICycleChecker cycleChecker ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } if (cycleChecker is null) { throw new ArgumentNullException(nameof(cycleChecker)); } _diagnosticReporter = diagnosticReporter; _cycleChecker = cycleChecker; }
public TimedTypeScanner( IDiagnosticReporter diagnosticReporter, ITypeScanner typeScanner ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } if (typeScanner is null) { throw new ArgumentNullException(nameof(typeScanner)); } _diagnosticReporter = diagnosticReporter; _typeScanner = typeScanner; }
public TimedBindExtractor( IDiagnosticReporter diagnosticReporter, DefaultBindExtractor bindExtractor ) { if (diagnosticReporter is null) { throw new System.ArgumentNullException(nameof(diagnosticReporter)); } if (bindExtractor is null) { throw new System.ArgumentNullException(nameof(bindExtractor)); } _diagnosticReporter = diagnosticReporter; _bindExtractor = bindExtractor; }
public DTimer( IDiagnosticReporter diagnosticReporter, string message ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } if (message is null) { throw new ArgumentNullException(nameof(message)); } _diagnosticReporter = diagnosticReporter; _message = message; _before = DateTime.Now; _after = _before; }
private void AnalyzeForMultipleUnconditionalChildExists( IDiagnosticReporter diagnosticReporter ) { if (diagnosticReporter is null) { throw new ArgumentNullException(nameof(diagnosticReporter)); } foreach (var pair in this.Box.Groups.Shuffle()) { var group = pair.Value; foreach (var bindingExtender in group.BindingExtenders) { if (Box.TryGetChildren(bindingExtender.BindingContainer, true, out var cpairs)) { var cgroups = ( from cpair in cpairs where !cpair.ConstructorArgument.DefineInBindNode group cpair by cpair.ConstructorArgument.Name into cgroup select cgroup ).ToList(); foreach (var cgroup in cgroups) { var cgpairs = cgroup.ToList(); var unconditionalCount = cgpairs.Count(p => !p.BindingExtender.BindingContainer.IsConditional); if (unconditionalCount > 1) { diagnosticReporter.ReportError( $"Multiple unconditional children has been found.", $"There are multiple unconditional children for [{bindingExtender.BindingContainer.TargetRepresentation}] and its constructor argument [{cgroup.Key}]." ); } } } } } }
public EmbeddingResolver( CSharpCompilation compilation, CSharpParseOptions parseOptions, IDiagnosticReporter reporter, EmbedderConfig config, CancellationToken cancellationToken = default) { var specificDiagnosticOptions = new Dictionary <string, ReportDiagnostic> { { "CS8019", ReportDiagnostic.Warn }, { "CS0105", ReportDiagnostic.Warn }, }; var opts = compilation.Options .WithSpecificDiagnosticOptions(specificDiagnosticOptions); this.ConcurrentBuild = opts.ConcurrentBuild; this.parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Diagnose); this.compilation = compilation.WithOptions(opts); this.reporter = reporter; this.config = config; this.cancellationToken = cancellationToken; }
public IndexOrderSelector(IDiagnosticReporter diagnostic, LayoutOrder order) { _declaredOrder = order; _diagnostic = diagnostic; }
public SourcebergGeneratorHostBuilder(ITypeSymbolProvider symbolProvider, ISourceAddition sourceAddition, IDiagnosticReporter <SourcebergGeneratorHostBuilder> diagnosticReporter) : base(symbolProvider, sourceAddition, diagnosticReporter) { }
private static void EvaluateCondition(MemberMetaInfo targetMember, Location attributeLocation, ConditionExpression conditions, IDiagnosticReporter reporter) { switch (conditions.Condition) { // Since all objects contain Equals(object), this is the least we call back into // TODO : Note we might still want to warn user about that a returning type doesn't contain a correct signature // For example : If we try to evaluate the member equals to true, // even if the member returns a type that is obvious that wouldn't evaluate with true, then it would still evaluate, but just to false case Condition.Equal: case Condition.NotEqual: break; // In these cases we need to check if either the return type implements IComparable or IComparable<T> // We might also want to warn about boxing issue if the given compared type is a valuetype and returning type only has IComparable though case Condition.GreaterThan: case Condition.GreaterThanOrEqual: case Condition.LessThan: case Condition.LessThanOrEqual: { // Valid compare types // Value Types : bool, char, byte, sbyte, ushort, short, int, uint, ulong, long, float, double // Ref Types : Types (but why), string (but why) // We currently consider 'null' to be not comparable, so there's this if (conditions.ComparedValue is null) { reporter.ReportDiagnostic(DiagnosticHelper.CompareValueInvalid(conditions, attributeLocation)); break; } // Valid implicit conversion for IComparable is matched with C# specification : // https://docs.microsoft.com/dotnet/csharp/language-reference/builtin-types/numeric-conversions // // [Possible Improvement] // TODO : We also don't support even if IComparation<T>'s T is implicit convertible from the compared type // We only support when it's primitive is implicitly convertible (supported by C# specification) to another primitive type // So types that only return IComparable<long> would work well with int numbers // // This can be done using a compilation extensions provided out of the box: // https://docs.microsoft.com/dotnet/api/microsoft.codeanalysis.csharp.csharpextensions.classifyconversion var returnType = targetMember.ReturnType !; var comparedType = conditions.ComparedValue.GetType(); if (!returnType.Implements(typeof(IComparable)) || !returnType.Implements(typeof(IComparable <>))) { reporter.ReportDiagnostic(DiagnosticHelper.ReturnTypeNotComparable(targetMember, conditions.Condition, attributeLocation)); break; } if (!returnType.Implements(typeof(IComparable <>).MakeGenericType(comparedType)) || !returnType.GetInterfaces(typeof(IComparable <>)).Any(x => x.IsImplicitConvertibleFrom(comparedType))) { reporter.ReportDiagnostic(DiagnosticHelper.ReturnTypeInvalidComparable(targetMember, comparedType, attributeLocation)); break; } break; } // Since all objects can be evaluated with is operator case Condition.IsTypeOf: case Condition.IsNotTypeOf: { if (!(conditions.ComparedValue is null) && conditions.ComparedValue.GetType() != typeof(Type)) { reporter.ReportDiagnostic(DiagnosticHelper.CompareValueInvalid(conditions, attributeLocation, ", it should be only a kind of Type and none other")); } break; } default: reporter.ReportDiagnostic(DiagnosticHelper.InvalidCondition(conditions.Condition, attributeLocation)); break; } }
/// <summary> /// Builds a code file template from the given RESX reader. /// </summary> /// <param name="reader">The resx reader the generated class is based on.</param> /// <param name="reporter">An object used to communicate diagnostics back to the caller.</param> /// <param name="typeResolver">An object used to resolve types by their name.</param> /// <returns>The completed code file template.</returns> private ResourceTemplate BuildTemplate(ResXResourceReader reader, IDiagnosticReporter reporter, ITypeResolutionService typeResolver = null) { var template = new ResourceTemplate { ClassName = ClassName, Namespace = Namespace, IsPublic = IsPublic, ResourceName = Namespace + "." + ClassName, }; reader.UseResXDataNodes = true; foreach (DictionaryEntry entry in reader) { if (entry.Value is ResXDataNode resxNode) { try { string typeName = resxNode.GetValueTypeName(typeResolver); bool isString = (typeName.Contains(typeof(string).FullName) == true); if (isString && resxNode.FileRef == null) { string str = (string)resxNode.GetValue(typeResolver); template.StringResources.Add( new StringResource(resxNode.Name, str, resxNode.Comment) ); } else if (isString) { template.TextFileResources.Add( new TextFileResource(resxNode.Name, resxNode.Comment) ); } else { string fullTypeName = typeName.Substring(0, typeName.IndexOf(',')); if (fullTypeName == typeof(MemoryStream).FullName) { template.StreamResources.Add( new StreamResource(resxNode.Name, resxNode.Comment) ); } else { template.ObjectResources.Add( new ObjectResource(resxNode.Name, fullTypeName, resxNode.Comment) ); } } } catch (Exception ex) { Trace.WriteLine( $"Caught exception while reading resource {entry.Key}: " + ex, nameof(BetterResourceGenerator) ); reporter.Report( DiagnosticSeverity.Error, $"Discarded resource {entry.Key} due to error: {ex.Message}." ); } } else { reporter.Report( DiagnosticSeverity.Warning, $"Discarded resource {entry.Key} as it is not a ResXDataNode." ); } } return(template); }
public void ValidateExternal(TypeMetaSelection selection, IGroupValidationProvider groupValidation, IDiagnosticReporter reporter) { var groupValidator = new FluentTypeValidator(selection, _conditionAnalyzer); groupValidation.ConfigureValidation(groupValidator); groupValidator.Validate(reporter); }
public void ValidateExternal(NamedTypeMetaInfo type, ITypeValidationProvider typeValidation, IDiagnosticReporter reporter) { var typeValidator = new FluentMemberValidator(TypeMetaSelection.Any(type), _conditionAnalyzer); typeValidation.ConfigureValidation(typeValidator); typeValidator.Validate(reporter); }
public InjectionWorkspace(IDiagnosticReporter diagnosticReporter) { this.diagnosticReporter = diagnosticReporter; diagnosticTimer = new SlidingTimer(TimeSpan.FromSeconds(1)); diagnosticTimer.TimeoutElapsed += HandleDiagnosticUpdateTimeout; }