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