public void ProcessGenericArgumentDataFlow(GenericParameter genericParameter, TypeReference genericArgument) { var genericParameterValue = _annotations.GetGenericParameterValue(genericParameter); Debug.Assert(genericParameterValue.DynamicallyAccessedMemberTypes != DynamicallyAccessedMemberTypes.None); MultiValue genericArgumentValue = GetTypeValueNodeFromGenericArgument(genericArgument); var diagnosticContext = new DiagnosticContext(_origin, ShouldEnableReflectionPatternReporting(_origin.Provider), _context); RequireDynamicallyAccessedMembers(diagnosticContext, genericArgumentValue, genericParameterValue); }
public ViewResult Index([FromQuery] string name = "SinjulMSBH") { Logger.LogInformation("Hello, {Name} .. !!!!", name); DiagnosticContext.Set("IndexCallCount", Interlocked.Increment(ref _callCount)); IEnumerable <ILoggerProvider> providers = LoggerProvider.Providers; ShoppingCartService.AddItem("SinjulMSBH", 130); return(View()); }
public ViewResult Index([FromQuery] string name = "SinjulMSBH") { Logger.LogInformation("Hello, {Name} .. !!!!", name); DiagnosticContext.Set("IndexCallCount", Interlocked.Increment(ref _callCount)); IEnumerable <ILoggerProvider> providers = new LoggerProviderCollection().Providers; Log.ForContext <ShoppingCartService>().Information("Adding {ItemId} x {Quantity} to cart", 13, 85); return(View()); }
public void MarkAndProduceDiagnostics(ReflectionMarker reflectionMarker, MarkStep markStep, LinkContext context) { bool diagnosticsEnabled = !context.Annotations.ShouldSuppressAnalysisWarningsForRequiresUnreferencedCode(Origin.Provider); var diagnosticContext = new DiagnosticContext(Origin, diagnosticsEnabled, context); ReflectionMethodBodyScanner.HandleCall(Operation, CalledMethod, Instance, Arguments, diagnosticContext, reflectionMarker, context, markStep, out MultiValue _); }
private static bool IsWellKnownModule(ISourceFile sourceFile, DiagnosticContext context) { if (context.Workspace == null) { // This rule is applicable only when the workspace is used. return(true); } var module = context.Workspace.GetModuleBySpecFileName(sourceFile.GetAbsolutePath(context.PathTable)); return(WellKnownTransformerWrappers.Contains(module.Descriptor.Name)); }
private void ValidateTypeNode(INode node, DiagnosticContext context) { if (IsWellKnownModule(node.GetSourceFile(), context)) { return; } var propertyAccess = node.Cast <ITypeReferenceNode>(); var identifier = propertyAccess.TypeName.As <IQualifiedName>()?.Left?.As <IIdentifier>(); CheckIdentifier(node, context, identifier); }
private void ValidateNode(INode node, DiagnosticContext context) { if (IsWellKnownModule(node.GetSourceFile(), context)) { return; } var propertyAccess = node.Cast <IPropertyAccessExpression>(); var identifier = propertyAccess.Expression.As <IIdentifier>(); CheckIdentifier(node, context, identifier); }
public RequestLoggingMiddleware(RequestDelegate next, DiagnosticContext diagnosticContext, RequestLoggingOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } _next = next ?? throw new ArgumentNullException(nameof(next)); _diagnosticContext = diagnosticContext ?? throw new ArgumentNullException(nameof(diagnosticContext)); _getLevel = options.GetLevel; _messageTemplate = new MessageTemplateParser().Parse(options.MessageTemplate); }
private void AnalyzeVariableStatement(INode node, DiagnosticContext context) { var variableStatement = node.Cast <IVariableStatement>(); // Don't need to check whether a statement was declared at the namespace level, // because we'll skip non-exported variable declarations. // And export keyword is applicable only for top level variables! // We only care about exported statements if ((variableStatement.Flags & NodeFlags.Export) == 0) { return; } var declarations = variableStatement.DeclarationList.Declarations; foreach (var declaration in declarations) { // 'any' is not allowed for top level variables if (declaration.Type?.Kind == TypeScript.Net.Types.SyntaxKind.AnyKeyword || NodeWalker.ForEachChildRecursively <Bool>(declaration.Type, n => n?.Kind == TypeScript.Net.Types.SyntaxKind.AnyKeyword)) { context.Logger.ReportNotAllowedTypeAnyOnTopLevelDeclaration( context.LoggingContext, declaration.LocationForLogging(context.SourceFile), declaration.Name.GetFormattedText(), Name); } // If the variable has an initializer (there is another lint rule that enforces variable initialization, // but that can't be assumed here) that is an object literal, then there should be a non-any type annotation if (declaration.Initializer?.Kind == TypeScript.Net.Types.SyntaxKind.ObjectLiteralExpression) { if (declaration.Type == null) { context.Logger.ReportMissingTypeAnnotationOnTopLevelDeclaration( context.LoggingContext, declaration.LocationForLogging(context.SourceFile), declaration.Name.GetFormattedText(), Name); } else if (declaration.Type.Kind == TypeScript.Net.Types.SyntaxKind.AnyKeyword) { context.Logger.ReportNotAllowedTypeAnyOnTopLevelDeclaration( context.LoggingContext, declaration.LocationForLogging(context.SourceFile), declaration.Name.GetFormattedText(), Name); } } } }
private static void CheckQualifierTypeNameIsNotUsed(INode node, DiagnosticContext context) { var interfaceDeclaration = node.As <IInterfaceDeclaration>(); var name = interfaceDeclaration != null ? interfaceDeclaration.Name.Text : node.As <ITypeAliasDeclaration>().Name.Text; if (name == Names.BaseQualifierType) { context.Logger.ReportQualifierTypeNameIsReserved( context.LoggingContext, node.LocationForLogging(context.SourceFile), Names.BaseQualifierType); } }
private static void ValidateStatement(INode node, DiagnosticContext context) { if (!node.IsTopLevelOrNamespaceLevelDeclaration()) { // Doing nothing if the declaration is not a namespace or top level declaration. return; } context.Logger.ReportOnlyTypeAndFunctionDeclarationsAndConstBindingsAreAllowedTopLevel( context.LoggingContext, node.LocationForLogging(context.SourceFile), node.Kind.ToString()); }
private static void CheckImportOrExportClause(INode node, DiagnosticContext context) { IExpression specifier = node.GetModuleSpecifier(); var literalExpression = specifier?.As <IStringLiteral>(); // There is a lint rule that enforces this, but it might have not run yet if (literalExpression == null) { return; } CheckImportedModule(node, literalExpression.Text, context); }
public void ProcessAttributeDataflow(MethodDefinition method, IList <CustomAttributeArgument> arguments) { for (int i = 0; i < method.Parameters.Count; i++) { var parameterValue = _annotations.GetMethodParameterValue(method, i); if (parameterValue.DynamicallyAccessedMemberTypes != DynamicallyAccessedMemberTypes.None) { MultiValue value = GetValueNodeForCustomAttributeArgument(arguments[i]); var diagnosticContext = new DiagnosticContext(_origin, diagnosticsEnabled: true, _context); RequireDynamicallyAccessedMembers(diagnosticContext, value, parameterValue); } } }
private static void CheckImportedModule(INode node, string moduleName, DiagnosticContext context) { var module = context.Workspace.GetModuleBySpecFileName(context.SourceFile.GetAbsolutePath(context.PathTable)); if (module.Definition.ResolutionSemantics == NameResolutionSemantics.ImplicitProjectReferences && module.Descriptor.Name == moduleName) { // The rule is enabled only for V2 modules. For V1 modules it still kind of make sense to import itself, instead of importing different files. context.Logger.ReportModuleShouldNotImportItself( context.LoggingContext, node.LocationForLogging(context.SourceFile), moduleName); } }
private void EnforceFunctionDeclareReturnType(INode node, DiagnosticContext context) { var functionDeclaration = node.As <IFunctionDeclaration>(); if (functionDeclaration.Type == null || functionDeclaration.Type.Kind == TypeScript.Net.Types.SyntaxKind.AnyKeyword) { context.Logger.ReportFunctionShouldDeclareReturnType( context.LoggingContext, functionDeclaration.LocationForLogging(context.SourceFile), functionDeclaration.Name.GetFormattedText(), Name); } }
private static void CheckImportFrom(INode node, DiagnosticContext context) { var callExpression = node.Cast <ICallExpression>(); if (!callExpression.IsImportFrom()) { return; } var moduleName = callExpression.Arguments[0].Cast <IStringLiteral>().Text; CheckImportedModule(node, moduleName, context); }
public void MarkAndProduceDiagnostics(ReflectionMarker reflectionMarker, Logger logger) { var diagnosticContext = new DiagnosticContext( Origin, logger.ShouldSuppressAnalysisWarningsForRequires(Origin.MemberDefinition, DiagnosticUtilities.RequiresUnreferencedCodeAttribute), logger.ShouldSuppressAnalysisWarningsForRequires(Origin.MemberDefinition, DiagnosticUtilities.RequiresDynamicCodeAttribute), logger.ShouldSuppressAnalysisWarningsForRequires(Origin.MemberDefinition, DiagnosticUtilities.RequiresAssemblyFilesAttribute), logger); ReflectionMethodBodyScanner.HandleCall(MethodBody, CalledMethod, Operation, Offset, Instance, Arguments, diagnosticContext, reflectionMarker, out MultiValue _); }
private void CheckIdentifier(INode node, DiagnosticContext context, IIdentifier identifier) { if (identifier == null || identifier.Text != AmbientNamespaceName) { return; } var symbol = context.SemanticModel.TypeChecker.GetSymbolAtLocation(identifier); if (IsPrelude(symbol?.DeclarationList.FirstOrDefault()?.GetSourceFile(), context)) { context.Logger.ReportAmbientTransformerIsDisallowed(context.LoggingContext, node.LocationForLogging(context.SourceFile), Name); } }
/// <summary> /// Register serilog /// </summary> /// <param name="services">service container</param> /// <param name="logPath">Path to file savelog</param> public static void AddSerilog(this IServiceCollection services, string logPath = "logs\\systemlog.txt") { Log.Logger = new LoggerConfiguration() .MinimumLevel.Debug() .MinimumLevel.Override("Microsoft", LogEventLevel.Warning) .Enrich.FromLogContext() .WriteTo.File(logPath, rollingInterval: RollingInterval.Day, encoding: Encoding.UTF8, rollOnFileSizeLimit: true) .CreateLogger(); var diagnosticContext = new DiagnosticContext(Log.Logger); services.AddSingleton(diagnosticContext); services.AddSingleton(Log.Logger); services.AddSingleton <ILoggerProvider, SerilogLoggerProvider>(); }
public void ProcessAttributeDataflow(FieldDefinition field, CustomAttributeArgument value) { MultiValue valueNode = GetValueNodeForCustomAttributeArgument(value); foreach (var fieldValueCandidate in GetFieldValue(field)) { if (fieldValueCandidate is not ValueWithDynamicallyAccessedMembers fieldValue) { continue; } var diagnosticContext = new DiagnosticContext(_origin, diagnosticsEnabled: true, _context); RequireDynamicallyAccessedMembers(diagnosticContext, valueNode, fieldValue); } }
private static void EnforceFunctionDeclareReturnType(INode node, DiagnosticContext context) { var functionDeclaration = node.As <IFunctionDeclaration>(); if (functionDeclaration.IsExported()) { if (functionDeclaration?.IsReturnTypeMutable(context.SemanticModel) == true || functionDeclaration?.HasMutableParameterType(context.SemanticModel) == true) { context.Logger.ReportNoMutableDeclarationsAtExposedFunctions( context.LoggingContext, functionDeclaration.LocationForLogging(context.SourceFile)); } } }
public void ScanAndProcessReturnValue(MethodBody methodBody) { Scan(methodBody); if (!methodBody.Method.ReturnsVoid()) { var method = methodBody.Method; var methodReturnValue = _annotations.GetMethodReturnValue(method); if (methodReturnValue.DynamicallyAccessedMemberTypes != 0) { var diagnosticContext = new DiagnosticContext(_origin, ShouldEnableReflectionPatternReporting(_origin.Provider), _context); RequireDynamicallyAccessedMembers(diagnosticContext, ReturnValue, methodReturnValue); } } }
private void ValidateNode(INode node, DiagnosticContext context) { var callExpression = node.Cast <ICallExpression>(); // We're interested only in invocation expression that're using named identifier. var callee = callExpression.Expression.As <IIdentifier>(); if (callee != null) { if (IsGlobFunction(callee.Text)) { context.Logger.ReportGlobFunctionsIsNotAllowed(context.LoggingContext, node.LocationForLogging(context.SourceFile), Name); } } }
public void ExistingPropertiesCanBeUpdated() { var dc = new DiagnosticContext(Some.Logger()); var collector = dc.BeginCollection(); dc.Set("name", 10); dc.Set("name", 20); Assert.True(collector.TryComplete(out var properties)); var prop = Assert.Single(properties); var scalar = Assert.IsType <ScalarValue>(prop.Value); Assert.Equal(20, scalar.Value); }
private static void CheckCallToEvalIsNotAllowed(INode node, DiagnosticContext context) { var expression = node.Cast <ICallExpression>(); if (expression.Expression.Kind == TypeScript.Net.Types.SyntaxKind.Identifier) { var expressionName = expression.Expression.Cast <IIdentifier>(); if (expressionName.Text == "eval") { context.Logger.ReportEvalIsNotAllowed( context.LoggingContext, expression.LocationForLogging(context.SourceFile)); } } }
private static void CheckExportSpecifierIsNotRootNamespace(INode node, DiagnosticContext context) { var export = node.Cast <IExportDeclaration>(); if (export.ExportClause != null) { // export {a as $} foreach (var namedExport in export.ExportClause.Elements) { if (ReportIfNameIsRootNamespace(namedExport.Name.Text, namedExport, context)) { return; } } } }
static IEnumerable <Diagnostic> GetDynamicallyAccessedMembersDiagnostics(SingleValue sourceValue, SingleValue targetValue, Location location) { // The target should always be an annotated value, but the visitor design currently prevents // declaring this in the type system. if (targetValue is not ValueWithDynamicallyAccessedMembers targetWithDynamicallyAccessedMembers) { throw new NotImplementedException(); } var diagnosticContext = new DiagnosticContext(location); var requireDynamicallyAccessedMembersAction = new RequireDynamicallyAccessedMembersAction(diagnosticContext, new ReflectionAccessAnalyzer()); requireDynamicallyAccessedMembersAction.Invoke(sourceValue, targetWithDynamicallyAccessedMembers); return(diagnosticContext.Diagnostics); }
private void DiscoverUrl() { string text = null; if (this.IsTraceEnabled(TraceType.DebugTrace)) { this.Tracer.TraceDebug <string>(0L, "Will try to discover the URL for EWS with the Backendlocator for mailbox {0}", this.connectionManager.GetPrincipalInfoForTracing()); } Exception innerException = null; try { Uri backEndWebServicesUrl = this.connectionManager.GetBackEndWebServicesUrl(); if (backEndWebServicesUrl != null) { if (this.IsTraceEnabled(TraceType.DebugTrace)) { this.Tracer.TraceDebug <string, string>(0L, "Found Uri from the back end locator.{0}, {1}", backEndWebServicesUrl.ToString(), this.connectionManager.GetPrincipalInfoForTracing()); } text = backEndWebServicesUrl.ToString(); } else if (this.IsTraceEnabled(TraceType.ErrorTrace)) { this.Tracer.TraceError <string>(0L, "Unable to discover internal URL for EWS for mailbox {0}. BackEndLocator call returned null", this.connectionManager.GetPrincipalInfoForTracing()); } } catch (LocalizedException ex) { DiagnosticContext.TraceLocation((LID)51388U); innerException = ex; if (this.IsTraceEnabled(TraceType.ErrorTrace)) { this.Tracer.TraceError <string, LocalizedException>(0L, "Unable to discover internal URL for EWS for mailbox {0} due to exception {1}", this.connectionManager.GetPrincipalInfoForTracing(), ex); } } if (string.IsNullOrEmpty(text)) { DiagnosticContext.TraceLocation((LID)45244U); throw new FailedToFindEwsEndpointException(this.connectionManager.GetPrincipalInfoForTracing(), innerException); } this.binding.Url = text; this.lastUrlDiscoverTime = ExDateTime.UtcNow; if (this.IsTraceEnabled(TraceType.DebugTrace)) { this.Tracer.TraceDebug(0L, "Refreshed service binding (url and adminauditlogs folder), new url: " + text); } }
public override MultiValue HandleMethodCall(IMethodSymbol calledMethod, MultiValue instance, ImmutableArray <MultiValue> arguments, IOperation operation) { // For .ctors: // - The instance value is empty (TopValue) and that's a bit wrong. // Technically this is an instance call and the instance is some valid value, we just don't know which // but for example it does have a static type. For now this is OK since we don't need the information // for anything yet. // - The return here is also technically problematic, the return value is an instance of a known type, // but currently we return empty (since the .ctor is declared as returning void). // Especially with DAM on type, this can lead to incorrectly analyzed code (as in unknown type which leads // to noise). Linker has the same problem currently: https://github.com/dotnet/linker/issues/1952 var diagnosticContext = DiagnosticContext.CreateDisabled(); var handleCallAction = new HandleCallAction(diagnosticContext, Context.OwningSymbol, operation); if (!handleCallAction.Invoke(new MethodProxy(calledMethod), instance, arguments, out MultiValue methodReturnValue)) { if (!calledMethod.ReturnsVoid && calledMethod.ReturnType.IsTypeInterestingForDataflow()) { methodReturnValue = new MethodReturnValue(calledMethod); } else { methodReturnValue = TopValue; } } TrimAnalysisPatterns.Add(new TrimAnalysisMethodCallPattern( calledMethod, instance, arguments, operation, Context.OwningSymbol)); foreach (var argument in arguments) { foreach (var argumentValue in argument) { if (argumentValue is ArrayValue arrayValue) { arrayValue.IndexValues.Clear(); } } } return(methodReturnValue); }
public static string GetDiagnosticContextFromThread() { if (!DiagnosticContext.HasData) { return(string.Empty); } byte[] array = DiagnosticContext.PackInfo(); byte[] array2 = new byte[array.Length + 6]; int num = 0; ExBitConverter.Write(0, array2, num); num += 2; ExBitConverter.Write((uint)array.Length, array2, num); num += 4; Array.Copy(array, 0, array2, num, array.Length); return(string.Format("[diag::{0}]", Convert.ToBase64String(array2))); }
/// <summary> /// Initializes a new instance of the <see cref="DiagnosticContext" /> class /// with the specified message and parent context. /// </summary> /// <param name="message">The message for this context.</param> /// <param name="parent">The parent context in the chain.</param> internal DiagnosticContext(string message, DiagnosticContext parent) { m_message = message; if (parent != null) { m_fullMessage = parent.FullMessage + ' ' + message; } else { m_fullMessage = message; } }