public void Analyze([NotNull] IReturnOperation returnStatement) { EvaluationResult result = AnalyzeExpression(returnStatement.ReturnedValue); if (result.IsConclusive && result.IsDeferred) { ReportDiagnosticAt(returnStatement, result.DeferredOperationName, context); } }
private Task VisitReturnAsync(IReturnOperation returnOperation, CancellationToken cancellationToken) { if (returnOperation.ReturnedValue is null) { return(Task.CompletedTask); } return(VisitAsync(returnOperation.ReturnedValue, cancellationToken)); }
private void AnalyzeReturnStatement([NotNull] IReturnOperation returnStatement, OperationBlockAnalysisContext context, [NotNull] IDictionary <ILocalSymbol, EvaluationResult> variableEvaluationCache) { if (!ReturnsConstant(returnStatement) && !IsYieldBreak(returnStatement)) { var analyzer = new ReturnValueAnalyzer(context, variableEvaluationCache); analyzer.Analyze(returnStatement); } }
void AnalyzeResponseExpression(IReturnOperation returnOperation) { var responseMetadata = InspectReturnOperation( localSymbolCache, returnOperation); if (responseMetadata is { } value) { localActualResponseMetadata.Add(value); }
private void ReportDiagnosticAt([NotNull] IReturnOperation returnStatement, [NotNull] string operationName) { Location location = returnStatement.GetLocationForKeyword(); ISymbol containingMember = context.OwningSymbol.GetContainingMember(); string memberName = containingMember.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat); Diagnostic diagnostic = operationName == QueryOperationName ? Diagnostic.Create(QueryRule, location, containingMember.Kind, memberName) : Diagnostic.Create(OperationRule, location, containingMember.Kind, memberName, operationName); context.ReportDiagnostic(diagnostic); }
private static void ReportReturnStatement([NotNull] IReturnOperation returnOperation, OperationAnalysisContext context) { IMethodSymbol method = returnOperation.TryGetContainingMethod(context.Compilation); if (method != null && !method.IsSynthesized()) { Location location = returnOperation.ReturnedValue.Syntax.GetLocation(); string kind = method.GetKind().ToLowerInvariant(); context.ReportDiagnostic(Diagnostic.Create(Rule, location, kind, method.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat))); } }
public override void VisitReturn(IReturnOperation operation) { Assert.Contains(operation.Kind, new[] { OperationKind.Return, OperationKind.YieldReturn, OperationKind.YieldBreak }); if (operation.ReturnedValue == null) { Assert.NotEqual(OperationKind.YieldReturn, operation.Kind); Assert.Empty(operation.Children); } else { Assert.Same(operation.ReturnedValue, operation.Children.Single()); } }
public override Location VisitReturn([NotNull] IReturnOperation operation, [CanBeNull] object argument) { if (operation.Syntax is ReturnStatementSyntax returnSyntax) { return(returnSyntax.ReturnKeyword.GetLocation()); } if (operation.Syntax is YieldStatementSyntax yieldSyntax) { return(GetLocationForYieldStatement(yieldSyntax)); } return(base.VisitReturn(operation, argument)); }
public IInterpetedOperation ReturnOperation(IReturnOperation co) { if (backing.TryGetValue(co, out var res)) { return(res); } else { var op = new InterpetedReturnOperation(); backing.Add(co, op); op.Init( co.Result.Convert(this)); return(op); } }
private IInterpetedOperation <IInterpetedAnyType> ReturnOperation <T>(IReturnOperation co) where T : class, IInterpetedAnyType { if (backing.TryGetValue(co, out var res)) { return(res); } else { var op = new InterpetedReturnOperation <T>(); backing.Add(co, op); op.Init( co.Result.Convert(this).Cast <IInterpetedOperation <T> >()); return(op); } }
private static void ReportDiagnosticAt([NotNull] IReturnOperation returnStatement, [NotNull] string operationName, OperationBlockAnalysisContext context) { Location location = returnStatement.TryGetLocationForKeyword(); if (location != null) { ISymbol containingMember = context.OwningSymbol.GetContainingMember(); string memberName = containingMember.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat); (DiagnosticDescriptor rule, object[] messageArguments) = GetArgumentsForReport(operationName, containingMember, memberName); Diagnostic diagnostic = Diagnostic.Create(rule, location, messageArguments); context.ReportDiagnostic(diagnostic); } }
public override void VisitReturn([NotNull] IReturnOperation operation) { if (scopeDepth == 0 && operation.ReturnedValue != null && !ReturnsConstant(operation.ReturnedValue) && MethodSignatureTypeIsEnumerable(operation.ReturnedValue)) { ITypeSymbol returnValueType = operation.ReturnedValue.SkipTypeConversions().Type; if (sequenceTypeInfo.IsQueryable(returnValueType)) { ReportDiagnosticAt(operation, QueryableOperationName, context); } else if (sequenceTypeInfo.IsNonQueryableSequenceType(returnValueType)) { ReturnStatements.Add(operation); } // ReSharper disable once RedundantIfElseBlock else { // No action required. } } base.VisitReturn(operation); }
public override IOperation VisitReturn(IReturnOperation operation, object argument) { return(new ReturnStatement(operation.Kind, Visit(operation.ReturnedValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit)); }
public IInterpetedOperation <IInterpetedAnyType> ReturnOperation(IReturnOperation co) { var method = GetMethod(new Type[] { TypeMap.MapType(co.Result.Returns()) }, nameof(ReturnOperation)); return(method.Invoke(this, new object[] { co }).Cast <IInterpetedOperation <IInterpetedAnyType> >()); }
protected override bool IsRef(IReturnOperation returnOperation) => returnOperation.Syntax is ReturnStatementSyntax statement &&
private static bool ReturnsStringOrCollectionOrTask([NotNull] IReturnOperation returnOperation, [NotNull][ItemNotNull] IList <INamedTypeSymbol> taskTypes) { return(ImplementsIEnumerable(returnOperation.ReturnedValue.Type) || IsTask(returnOperation.ReturnedValue.Type, taskTypes)); }
protected abstract bool IsRef(IReturnOperation returnOperation);
public override bool VisitReturn([NotNull] IReturnOperation operation1, [CanBeNull] IOperation argument) { return(argument is IReturnOperation operation2 && AreBaseOperationsEqual(operation1, operation2)); }
public static bool TryMatchPattern( ISyntaxFactsService syntaxFacts, IConditionalOperation ifOperation, out IReturnOperation trueReturn, out IReturnOperation falseReturn) { trueReturn = null; falseReturn = null; var trueStatement = ifOperation.WhenTrue; var falseStatement = ifOperation.WhenFalse; // we support: // // if (expr) // return a; // else // return b; // // and // // if (expr) // return a; // // return b; if (falseStatement == null) { var parentBlock = ifOperation.Parent as IBlockOperation; if (parentBlock == null) { return(false); } var ifIndex = parentBlock.Operations.IndexOf(ifOperation); if (ifIndex < 0) { return(false); } if (ifIndex + 1 < parentBlock.Operations.Length) { falseStatement = parentBlock.Operations[ifIndex + 1]; if (falseStatement.IsImplicit) { return(false); } } } trueStatement = UseConditionalExpressionHelpers.UnwrapSingleStatementBlock(trueStatement); falseStatement = UseConditionalExpressionHelpers.UnwrapSingleStatementBlock(falseStatement); // Both return-statements must be of the form "return value" if (!(trueStatement is IReturnOperation trueReturnOp) || !(falseStatement is IReturnOperation falseReturnOp) || trueReturnOp.ReturnedValue == null || falseReturnOp.ReturnedValue == null) { return(false); } if (trueReturnOp.Kind != falseReturnOp.Kind) { // Not allowed if these are different types of returns. i.e. // "yield return ..." and "return ...". return(false); } if (trueReturnOp.Kind == OperationKind.YieldBreak) { // This check is just paranoia. We likely shouldn't get here since we already // checked if .ReturnedValue was null above. return(false); } if (trueReturnOp.Kind == OperationKind.YieldReturn && ifOperation.WhenFalse == null) { // we have the following: // // if (...) { // yield return ... // } // // yield return ... // // It is *not* correct to replace this with: // // yield return ... ? ... ? ... // // as both yields need to be hit. return(false); } trueReturn = trueReturnOp; falseReturn = falseReturnOp; return(UseConditionalExpressionHelpers.CanConvert( syntaxFacts, ifOperation, trueReturn, falseReturn)); }
public ActualApiResponseMetadata(IReturnOperation returnExpression, int statusCode, ITypeSymbol?returnType) { ReturnOperation = returnExpression; _statusCode = statusCode; ReturnType = returnType; }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); // Security analyzer - analyze and report diagnostics on generated code. context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics); context.RegisterCompilationStartAction( (CompilationStartAnalysisContext compilationStartAnalysisContext) => { if (!compilationStartAnalysisContext.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemWebHttpCookie, out INamedTypeSymbol? httpCookieSymbol)) { return; } PooledHashSet <(IOperation Operation, ISymbol ContainingSymbol)> rootOperationsNeedingAnalysis = PooledHashSet <(IOperation, ISymbol)> .GetInstance(); compilationStartAnalysisContext.RegisterOperationBlockStartAction( (OperationBlockStartAnalysisContext operationBlockStartAnalysisContext) => { ISymbol owningSymbol = operationBlockStartAnalysisContext.OwningSymbol; if (owningSymbol.IsConfiguredToSkipAnalysis( operationBlockStartAnalysisContext.Options, Rule, operationBlockStartAnalysisContext.Compilation, operationBlockStartAnalysisContext.CancellationToken)) { return; } operationBlockStartAnalysisContext.RegisterOperationAction( (OperationAnalysisContext operationAnalysisContext) => { ISimpleAssignmentOperation simpleAssignmentOperation = (ISimpleAssignmentOperation)operationAnalysisContext.Operation; if (simpleAssignmentOperation.Target is IPropertyReferenceOperation propertyReferenceOperation && httpCookieSymbol.Equals(propertyReferenceOperation.Property.ContainingType) && propertyReferenceOperation.Property.Name == "HttpOnly" && simpleAssignmentOperation.Value.ConstantValue.HasValue && simpleAssignmentOperation.Value.ConstantValue.Value.Equals(false)) { operationAnalysisContext.ReportDiagnostic( simpleAssignmentOperation.CreateDiagnostic( Rule)); } }, OperationKind.SimpleAssignment); operationBlockStartAnalysisContext.RegisterOperationAction( (OperationAnalysisContext operationAnalysisContext) => { IReturnOperation returnOperation = (IReturnOperation)operationAnalysisContext.Operation; if (httpCookieSymbol.Equals(returnOperation.ReturnedValue?.Type)) { lock (rootOperationsNeedingAnalysis) { rootOperationsNeedingAnalysis.Add( (returnOperation.GetRoot(), operationAnalysisContext.ContainingSymbol)); } } }, OperationKind.Return); operationBlockStartAnalysisContext.RegisterOperationAction( (OperationAnalysisContext operationAnalysisContext) => { IArgumentOperation argumentOperation = (IArgumentOperation)operationAnalysisContext.Operation; if (httpCookieSymbol.Equals(argumentOperation.Value.Type)) { lock (rootOperationsNeedingAnalysis) { rootOperationsNeedingAnalysis.Add( (argumentOperation.GetRoot(), operationAnalysisContext.ContainingSymbol)); } } }, OperationKind.Argument); }); compilationStartAnalysisContext.RegisterCompilationEndAction( (CompilationAnalysisContext compilationAnalysisContext) => { PooledDictionary <(Location Location, IMethodSymbol?Method), HazardousUsageEvaluationResult>?allResults = null; try { lock (rootOperationsNeedingAnalysis) { if (!rootOperationsNeedingAnalysis.Any()) { return; } allResults = PropertySetAnalysis.BatchGetOrComputeHazardousUsages( compilationAnalysisContext.Compilation, rootOperationsNeedingAnalysis, compilationAnalysisContext.Options, WellKnownTypeNames.SystemWebHttpCookie, ConstructorMapper, PropertyMappers, HazardousUsageEvaluators, InterproceduralAnalysisConfiguration.Create( compilationAnalysisContext.Options, SupportedDiagnostics, defaultInterproceduralAnalysisKind: InterproceduralAnalysisKind.ContextSensitive, cancellationToken: compilationAnalysisContext.CancellationToken)); } if (allResults == null) { return; } foreach (KeyValuePair <(Location Location, IMethodSymbol?Method), HazardousUsageEvaluationResult> kvp in allResults) { if (kvp.Value == HazardousUsageEvaluationResult.Flagged) { compilationAnalysisContext.ReportDiagnostic( Diagnostic.Create( Rule, kvp.Key.Location)); } } } finally { rootOperationsNeedingAnalysis.Free(); allResults?.Free(); } }); }); }
public Nothing ReturnOperation(IReturnOperation co) { Push(co).Walk(co.Operands); return(new Nothing()); }
private static AbstractStatement ReadReturn(IReturnOperation op) { return(new ReturnStatement { Expression = ReadExpression(op.ReturnedValue) }); }
public IReadOnlyList <IMemberDefinition> ReturnOperation(IReturnOperation co) { return(co.Result.Convert(this)); }
public ActualApiResponseMetadata(IReturnOperation returnExpression, ITypeSymbol returnType) { ReturnOperation = returnExpression; ReturnType = returnType; _statusCode = null; }
public override void VisitReturn([NotNull] IReturnOperation operation) { base.VisitReturn(operation); }
public override NullAbstractValue VisitReturn(IReturnOperation operation, object argument) { var _ = base.VisitReturn(operation, argument); return(NullAbstractValue.NotNull); }
public virtual void VisitReturn(IReturnOperation operation) { DefaultVisit(operation); }
public override void VisitReturn([NotNull] IReturnOperation operation) { IncrementStatementCount(operation); base.VisitReturn(operation); }
public static bool TryMatchPattern( ISyntaxFactsService syntaxFacts, IConditionalOperation ifOperation, out IReturnOperation trueReturn, out IReturnOperation falseReturn) { trueReturn = null; falseReturn = null; var trueStatement = ifOperation.WhenTrue; var falseStatement = ifOperation.WhenFalse; // we support: // // if (expr) // return a; // else // return b; // // and // // if (expr) // return a; // // return b; if (falseStatement == null) { var parentBlock = ifOperation.Parent as IBlockOperation; if (parentBlock == null) { return(false); } var ifIndex = parentBlock.Operations.IndexOf(ifOperation); if (ifIndex < 0) { return(false); } if (ifIndex + 1 < parentBlock.Operations.Length) { falseStatement = parentBlock.Operations[ifIndex + 1]; if (falseStatement.IsImplicit) { return(false); } } } trueStatement = UseConditionalExpressionHelpers.UnwrapSingleStatementBlock(trueStatement); falseStatement = UseConditionalExpressionHelpers.UnwrapSingleStatementBlock(falseStatement); // Both return-statements must be of the form "return value" if (!(trueStatement is IReturnOperation trueReturnOp) || !(falseStatement is IReturnOperation falseReturnOp) || trueReturnOp.ReturnedValue == null || falseReturnOp.ReturnedValue == null) { return(false); } trueReturn = trueReturnOp; falseReturn = falseReturnOp; return(UseConditionalExpressionHelpers.CanConvert( syntaxFacts, ifOperation, trueReturn, falseReturn)); }