public static bool TryMatchPattern(
ISyntaxFacts syntaxFacts,
IConditionalOperation ifOperation,
out ISimpleAssignmentOperation trueAssignment,
out ISimpleAssignmentOperation falseAssignment)
{
trueAssignment = null;
falseAssignment = null;
var trueStatement = ifOperation.WhenTrue;
var falseStatement = ifOperation.WhenFalse;
trueStatement = UseConditionalExpressionHelpers.UnwrapSingleStatementBlock(trueStatement);
falseStatement = UseConditionalExpressionHelpers.UnwrapSingleStatementBlock(falseStatement);
if (!TryGetAssignment(trueStatement, out trueAssignment) ||
!TryGetAssignment(falseStatement, out falseAssignment))
{
return(false);
}
// The left side of both assignment statements has to be syntactically identical (modulo
// trivia differences).
if (!syntaxFacts.AreEquivalent(trueAssignment.Target.Syntax, falseAssignment.Target.Syntax))
{
return(false);
}
return(UseConditionalExpressionHelpers.CanConvert(
syntaxFacts, ifOperation, trueAssignment, falseAssignment));
}
private bool TryConvertWhenAssignmentToLocalDeclaredImmediateAbove(
ISyntaxFactsService syntaxFacts, SyntaxEditor editor, IConditionalOperation ifOperation,
ISimpleAssignmentOperation trueAssignment, ISimpleAssignmentOperation falseAssignment,
TExpressionSyntax conditionalExpression)
{
if (!TryFindMatchingLocalDeclarationImmediatelyAbove(
ifOperation, trueAssignment, falseAssignment,
out var localDeclarationOperation, out var declarator))
{
return(false);
}
// We found a valid local declaration right above the if-statement.
var localDeclaration = localDeclarationOperation.Syntax;
var variable = GetDeclaratorSyntax(declarator);
// Initialize that variable with the conditional expression.
var updatedVariable = WithInitializer(variable, conditionalExpression);
// Because we merged the initialization and the variable, the variable may now be able
// to use 'var' (c#), or elide its type (vb). Add the simplification annotation
// appropriately so that can happen later down the line.
var updatedLocalDeclaration = localDeclaration.ReplaceNode(variable, updatedVariable);
updatedLocalDeclaration = AddSimplificationToType(
(TLocalDeclarationStatementSyntax)updatedLocalDeclaration);
editor.ReplaceNode(localDeclaration, updatedLocalDeclaration);
editor.RemoveNode(ifOperation.Syntax, GetRemoveOptions(syntaxFacts, ifOperation.Syntax));
return(true);
}
public override void VisitSimpleAssignment(ISimpleAssignmentOperation operation)
{
Assert.Equal(OperationKind.SimpleAssignment, operation.Kind);
bool isRef = operation.IsRef;
VisitAssignment(operation);
}
public static void RegisterMemberAccess(this AnalysisContext context, Action <InvocationAnalysisContext> action)
{
var operationKinds = new[]
{
OperationKind.Invocation,
OperationKind.SimpleAssignment,
OperationKind.VariableDeclaration,
OperationKind.ObjectCreation,
OperationKind.FieldInitializer,
OperationKind.FieldReference,
};
context.RegisterOperationAction(ctx =>
{
ISymbol?symbol = ctx.Operation switch
{
IInvocationOperation invocation => invocation.TargetMethod,
IPropertyReferenceOperation property => property.Property.Type,
IObjectCreationOperation creation => creation.Type,
ISimpleAssignmentOperation assignment => assignment.Type,
IFieldInitializerOperation fieldInitializer => fieldInitializer.Type,
IFieldReferenceOperation fieldRef => fieldRef.Type,
IVariableDeclarationOperation variableDeclaration => variableDeclaration.Type,
_ => null,
};
if (symbol is null)
{
return;
}
var location = ctx.Operation.Syntax.GetLocation();
var newCtx = new InvocationAnalysisContext(symbol, location, ctx.Compilation, ctx.Options, ctx.ReportDiagnostic, ctx.CancellationToken);
action(newCtx);
}, operationKinds);
context.RegisterSymbolAction(ctx =>
{
var symbol = ctx.Symbol switch
{
IPropertySymbol property => property.Type,
IParameterSymbol parameter => parameter.Type,
IMethodSymbol method => method.ReturnsVoid ? null : method.ReturnType,
IFieldSymbol field => field.Type,
_ => null,
};
if (symbol is null)
{
return;
}
var location = ctx.Symbol.Locations[0];
var newCtx = new InvocationAnalysisContext(symbol, location, ctx.Compilation, ctx.Options, ctx.ReportDiagnostic, ctx.CancellationToken);
action(newCtx);
}, SymbolKind.Property, SymbolKind.Method, SymbolKind.Parameter, SymbolKind.Field);
}
public override void VisitSimpleAssignment([NotNull] ISimpleAssignmentOperation operation)
{
base.VisitSimpleAssignment(operation);
if (operation.Target is ILocalReferenceOperation targetLocal && currentLocal.Equals(targetLocal.Local))
{
AnalyzeAssignmentValue(operation.Value);
}
}
public override void VisitSimpleAssignment([NotNull] ISimpleAssignmentOperation operation)
{
if (operation.Target is ILocalReferenceOperation targetLocal && local.Equals(targetLocal.Local))
{
TrySetEvent(operation.Value);
}
base.VisitSimpleAssignment(operation);
}
private static bool AnalyzeAssignmentToMember <T>(ISimpleAssignmentOperation assignmentOperation, T instance, Func <T, T, bool> equalityComparer) where T : class, IOperation
{
// Check every simple assignments target in a statement for equality to `instance`
while (assignmentOperation.Value.Kind == OperationKind.SimpleAssignment)
{
assignmentOperation = (ISimpleAssignmentOperation)assignmentOperation.Value;
if (assignmentOperation.Target is T operationValue &&
equalityComparer(instance, operationValue))
{
return(true);
}
}
return(false);
}
private static bool TryGetAssignment(
IOperation statement, out ISimpleAssignmentOperation assignment)
{
// Both the WhenTrue and WhenFalse statements must be of the form:
// target = value;
if (!(statement is IExpressionStatementOperation exprStatement) ||
!(exprStatement.Operation is ISimpleAssignmentOperation assignmentOp) ||
assignmentOp.Target == null)
{
assignment = default;
return(false);
}
assignment = assignmentOp;
return(true);
}
private void ConvertOnlyIfToConditionalExpression(
SyntaxEditor editor, IConditionalOperation ifOperation,
ISimpleAssignmentOperation trueAssignment, ISimpleAssignmentOperation falseAssignment,
TExpressionSyntax conditionalExpression)
{
var generator = editor.Generator;
var ifStatement = (TIfStatementSyntax)ifOperation.Syntax;
var expressionStatement = (TStatementSyntax)generator.ExpressionStatement(
generator.AssignmentStatement(
trueAssignment.Target.Syntax,
conditionalExpression)).WithTriviaFrom(ifStatement);
editor.ReplaceNode(
ifOperation.Syntax,
this.WrapWithBlockIfAppropriate(ifStatement, expressionStatement));
}
/// <summary>
/// Gets the operation for the object being created that is being referenced by <paramref name="operation"/>.
/// If the operation is referencing an implicit or an explicit this/base/Me/MyBase/MyClass instance, then we return "null".
/// </summary>
public static IOperation GetInstance(this IInstanceReferenceOperation operation)
{
// VB object initializer allows accessing the members of the object being created with "." operator.
// The syntax of such an IInstanceReferenceOperation points to the object being created.
// Check for such an IObjectCreationOperation or IAnonymousObjectCreationOperation with matching syntax.
// For example, instance reference for members ".Field1" and ".Field2" in "New C() With { .Field1 = 0, .Field2 = .Field1 }".
Func <IObjectCreationOperation, bool> isObjectCreation = creation => creation.Syntax == operation.Syntax;
var objectCreation = operation.GetAncestor(OperationKind.ObjectCreation, isObjectCreation);
if (objectCreation != null)
{
return(objectCreation);
}
Func <IAnonymousObjectCreationOperation, bool> isAnonymousObjectCreation = creation => creation.Syntax == operation.Syntax;
var anonymousObjectCreation = operation.GetAncestor(OperationKind.AnonymousObjectCreation, isAnonymousObjectCreation);
if (anonymousObjectCreation != null)
{
return(anonymousObjectCreation);
}
// IInstanceReferenceOperation on left of an IMemberInitializerOperation refers to the ancestor IObjectCreationOperation/IAnonymousObjectCreationOperation/IMemberInitializerOperation.
// For example, implicit instance reference for member initializer "AnotherType" in "new C() { AnotherType = { IntField = 0 } };", where "AnotherType" is a member of named type kind.
IMemberInitializerOperation parentMemberInitializer = operation.GetAncestor <IMemberInitializerOperation>(OperationKind.MemberInitializer);
if (parentMemberInitializer != null &&
parentMemberInitializer.InitializedMember.DescendantsAndSelf().Contains(operation))
{
return(parentMemberInitializer.GetCreation());
}
// IInstanceReferenceOperation on left of an ISimpleAssignmentOperation with an IObjectOrCollectionInitializerOperation parent refers to the parenting IObjectCreationOperation/IAnonymousObjectCreationOperation/IMemberInitializerOperation.
// For example, implicit instance reference for "IntField" in "new C() { IntField = 0 };".
ISimpleAssignmentOperation parentSimpleAssignmentInitialier = operation.GetAncestor <ISimpleAssignmentOperation>(OperationKind.SimpleAssignment);
if (parentSimpleAssignmentInitialier != null &&
parentSimpleAssignmentInitialier.Parent is IObjectOrCollectionInitializerOperation &&
parentSimpleAssignmentInitialier.Target.DescendantsAndSelf().Contains(operation))
{
return(parentSimpleAssignmentInitialier.Parent.Parent);
}
// For all cases, IInstanceReferenceOperation refers to the implicit or explicit this/base/Me/MyBase/MyClass reference.
// We return null for such cases.
return(null);
}
public override void VisitSimpleAssignment(ISimpleAssignmentOperation operation)
{
base.VisitSimpleAssignment(operation);
//TODO: support other than local references
var target = operation.Target as ILocalReferenceOperation;
if (!target.Type.IsNullable())
{
return;
}
var targetEval = CurrentEval[target.Local];
var value = operation.Value;
if (value is IConversionOperation conversion)
{
value = conversion.Operand;
}
switch (value)
{
case ILiteralOperation _ when value.ConstantValue.HasValue && value.ConstantValue.Value == null: //null value
case IDefaultValueOperation _: //default value
targetEval.Update(NullLatticeValue.Null);
break;
case ILiteralOperation literal:
case IObjectCreationOperation constructorCall:
targetEval.Update(NullLatticeValue.NotNull);
break;
case ILocalReferenceOperation localRef:
var sourceRef = CurrentEval[localRef.Local];
targetEval.Update(sourceRef.Value);
break;
case IFieldReferenceOperation fieldRef when fieldRef.Field.ContainingType.Name == "String" && fieldRef.Field.Name == "Empty":
targetEval.Update(NullLatticeValue.NotNull);
break;
default:
throw new NotImplementedException();
}
}
private bool TryFindMatchingLocalDeclarationImmediatelyAbove(
IConditionalOperation ifOperation, ISimpleAssignmentOperation trueAssignment, ISimpleAssignmentOperation falseAssignment,
out IVariableDeclarationGroupOperation localDeclaration, out IVariableDeclaratorOperation declarator)
{
localDeclaration = null;
declarator = null;
// See if both assignments are to the same local.
if (!(trueAssignment.Target is ILocalReferenceOperation trueLocal) ||
!(falseAssignment.Target is ILocalReferenceOperation falseLocal) ||
!Equals(trueLocal.Local, falseLocal.Local))
{
return(false);
}
// If so, see if that local was declared immediately above the if-statement.
var parentBlock = ifOperation.Parent as IBlockOperation;
if (parentBlock == null)
{
return(false);
}
var ifIndex = parentBlock.Operations.IndexOf(ifOperation);
if (ifIndex <= 0)
{
return(false);
}
localDeclaration = parentBlock.Operations[ifIndex - 1] as IVariableDeclarationGroupOperation;
if (localDeclaration == null)
{
return(false);
}
if (localDeclaration.Declarations.Length != 1)
{
return(false);
}
var declaration = localDeclaration.Declarations[0];
var declarators = declaration.Declarators;
if (declarators.Length != 1)
{
return(false);
}
declarator = declarators[0];
var variable = declarator.Symbol;
if (!Equals(variable, trueLocal.Local))
{
// wasn't a declaration of the local we're assigning to.
return(false);
}
var variableName = variable.Name;
var variableInitializer = declarator.Initializer ?? declaration.Initializer;
if (variableInitializer?.Value != null)
{
var unwrapped = UnwrapImplicitConversion(variableInitializer.Value);
// the variable has to either not have an initializer, or it needs to be basic
// literal/default expression.
if (!(unwrapped is ILiteralOperation) &&
!(unwrapped is IDefaultValueOperation))
{
return(false);
}
}
// If the variable is referenced in the condition of the 'if' block, we can't merge the
// declaration and assignments.
return(!ReferencesLocalVariable(ifOperation.Condition, variable));
}
private void ProcessSimpleAssignmentOper(ISimpleAssignmentOperation assignOper, List <string> sharedFields, IOperation inst)
{
if (assignOper.Syntax.Kind().ToString() == "SimpleAssignmentExpression")
{
AssignmentExpressionSyntax assignSynt = (AssignmentExpressionSyntax)assignOper.Syntax;
string leftOperand = "";
int leftIndex = -1;
if (assignSynt.Left.Kind().ToString() == "IdentifierName")
{
IdentifierNameSyntax leftOperandExpr = (IdentifierNameSyntax)assignSynt.Left;
leftOperand = leftOperandExpr.Identifier.ToString();
leftIndex = sharedFields.IndexOf(leftOperand);
}
else if (assignSynt.Left.Kind().ToString() == "SimpleMemberAccessExpression")
{
MemberAccessExpressionSyntax leftOperandExpr = (MemberAccessExpressionSyntax)assignSynt.Left;
leftOperand = leftOperandExpr.Name.ToString();
leftIndex = sharedFields.IndexOf(leftOperand);
}
string rightOperand = "";
int rightIndex = -1;
if (assignSynt.Right.Kind().ToString() == "IdentifierName")
{
IdentifierNameSyntax rightOperandExpr = (IdentifierNameSyntax)assignSynt.Right;
rightOperand = rightOperandExpr.Identifier.ToString();
rightIndex = sharedFields.IndexOf(rightOperand);
if (rightIndex != -1 || methodInvocReturnRegs.IndexOf(rightOperand) != -1)
{
//Debug.Assert(leftIndex == 0);
conflictUnit.Add(new Tuple <Accesses, string, IOperation>(Accesses.Read, rightOperand, inst));
}
}
else if (assignSynt.Right.Kind().ToString() == "SimpleMemberAccessExpression")
{
MemberAccessExpressionSyntax rightOperandExpr = (MemberAccessExpressionSyntax)assignSynt.Right;
rightOperand = rightOperandExpr.Name.ToString();
rightIndex = sharedFields.IndexOf(rightOperand);
if (rightIndex != -1)
{
//Debug.Assert(leftIndex == 0);
conflictUnit.Add(new Tuple <Accesses, string, IOperation>(Accesses.Write, rightOperand, inst));
}
}
else if (assignSynt.Right.Kind().ToString() == "InvocationExpression")
{
InvocationExpressionSyntax invocInst = (InvocationExpressionSyntax)assignSynt.Right;
ProcessInvocationExpr(invocInst, inst, leftOperand);
//conflictUnit.Add(new Tuple<Accesses, string, IOperation>(Accesses.Invocation, "", inst));
}
else if (assignSynt.Right.Kind().ToString() == "AwaitExpression")
{
AwaitExpressionSyntax awaitInst = (AwaitExpressionSyntax)assignSynt.Right;
if (awaitInst.Expression.Kind().ToString() == "InvocationExpression")
{
InvocationExpressionSyntax invocInst = (InvocationExpressionSyntax)awaitInst.Expression;
ProcessInvocationExpr(invocInst, inst, leftOperand);
isAsync = true;
}
else if (awaitInst.Expression.Kind().ToString() == "IdentifierName")
{
IdentifierNameSyntax indentInst = (IdentifierNameSyntax)awaitInst.Expression;
isAsync = true;
rightOperand = indentInst.Identifier.ValueText;
awaitInvocRel.Add(new Tuple <string, string>(rightOperand, leftOperand));
methodInvocReturnRegs.Add(leftOperand);
}
conflictUnit.Add(new Tuple <Accesses, string, IOperation>(Accesses.Await, leftOperand, inst));
}
if (leftIndex != -1)
{
//Debug.Assert(rightIndex == 0);
conflictUnit.Add(new Tuple <Accesses, string, IOperation>(Accesses.Write, leftOperand, inst));
}
}
}
private void MethodSummary(ImmutableArray <BasicBlock> bb, List <string> sharedFields)
{
foreach (BasicBlock b in bb)
{
var a = b.GetType();
var c = b.BranchValue;
if (b.Operations != null)
{
foreach (IOperation inst in b.Operations)
{
//Console.WriteLine($"inst.Syntax.ToSring() '{inst.Syntax.ToString()}'");
if (inst.Kind.ToString() == "ExpressionStatement")
{
IExpressionStatementOperation exprInst = (IExpressionStatementOperation)inst;
if (exprInst.Operation != null)
{
//if (exprInst.Operation.Kind.ToString() == Kind = SimpleAssignment)
//if (exprInst.Operation.Kind.ToString() == Kind = SimpleAssignment)
if (exprInst.Operation.Kind.ToString() == "SimpleAssignment")
{
ISimpleAssignmentOperation assignInst = (ISimpleAssignmentOperation)exprInst.Operation;
ProcessSimpleAssignmentOper(assignInst, sharedFields, inst);
}
else if (exprInst.Operation.Kind.ToString() == "Await")
{
IAwaitOperation awaitInst = (IAwaitOperation)exprInst.Operation;
if (awaitInst.Operation.Kind.ToString() == "Invocation")
{
IInvocationOperation invocInst = (IInvocationOperation)awaitInst.Operation;
string leftOperand = "";
ProcessInvocationOper(invocInst, inst, leftOperand);
isAsync = true;
//conflictUnit.Add(new Tuple<Accesses, string, IOperation>(Accesses.Invocation, "", inst));
}
else if (awaitInst.Operation.Kind.ToString() == "Invalid")
{
ExpressionSyntax localvar = (ExpressionSyntax)awaitInst.Operation.Syntax;
//var v = localvar.Kind().ToString();
if (localvar.Kind().ToString() == "InvocationExpression")
{
InvocationExpressionSyntax invocInst = (InvocationExpressionSyntax)localvar;
string leftOperand = "";
ProcessInvocationExpr(invocInst, inst, leftOperand);
isAsync = true;
}
}
else if (awaitInst.Operation.Kind.ToString() == "IdentifierName")
{
//IdentifierNameSyntax indentInst = (IdentifierNameSyntax)awaitInst.Operation;
isAsync = true;
//rightOperand = indentInst.Identifier.ValueText;
//awaitInvocRel.Add(new Tuple<string, string>(rightOperand, leftOperand));
}
conflictUnit.Add(new Tuple <Accesses, string, IOperation>(Accesses.Await, invocSuffix, inst));
}
else if (exprInst.Operation.Kind.ToString() == "Invocation")
{
IInvocationOperation invocInst = (IInvocationOperation)exprInst.Operation;
string leftOperand = "";
ProcessInvocationOper(invocInst, inst, leftOperand);
//conflictUnit.Add(new Tuple<Accesses, string, IOperation>(Accesses.Invocation, "", inst));
// invocSyntax = Regex.Replace(invocSyntax, @"(\w.*)(\.Wait\(\))$", "$1");
//invocSyntax = Regex.Replace(invocSyntax, @"(\w.*)(\.)(\w.*)$", "$3");
}
}
}
else if (inst.Kind.ToString() == "SimpleAssignment")
{
ISimpleAssignmentOperation exprInst = (ISimpleAssignmentOperation)inst;
ProcessSimpleAssignmentOper(exprInst, sharedFields, inst);
}
}
}
}
}
public virtual void VisitSimpleAssignment(ISimpleAssignmentOperation operation)
{
DefaultVisit(operation);
}
public override void VisitSimpleAssignment([NotNull] ISimpleAssignmentOperation operation)
{
RegisterAssignment(operation.Target);
base.VisitSimpleAssignment(operation);
}
public override bool VisitSimpleAssignment([NotNull] ISimpleAssignmentOperation operation1,
[CanBeNull] IOperation argument)
{
return(argument is ISimpleAssignmentOperation operation2 && AreBaseOperationsEqual(operation1, operation2) &&
operation1.IsRef == operation2.IsRef);
}
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 override void VisitSimpleAssignment(ISimpleAssignmentOperation operation)
{
bool isRef = operation.IsRef;
base.VisitSimpleAssignment(operation);
}
public override Scope VisitSimpleAssignment(ISimpleAssignmentOperation operation, Scope currentScope)
{
var newScope = operation.Target.Accept(this, currentScope);
return(operation.Value.Accept(this, newScope));
}
public override TAbstractAnalysisValue VisitSimpleAssignment(ISimpleAssignmentOperation operation, object argument)
{
return(VisitAssignmentOperation(operation, argument));
}
public override Scope VisitSimpleAssignment(ISimpleAssignmentOperation operation, Scope currentScope) => operation.Target.Accept(this, currentScope);
public override IOperation VisitSimpleAssignment(ISimpleAssignmentOperation operation, object argument)
{
return(new SimpleAssignmentExpression(Visit(operation.Target), operation.IsRef, Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="operation">IOperationインスタンス</param>
/// <param name="container">イベントコンテナ</param>
public SimpleAssignment(ISimpleAssignmentOperation operation, EventContainer container) : base(container)
{
Expressions.AddRange(OperationFactory.GetExpressionList(operation.Target, container));
Expressions.Add(new Expression("=", string.Empty));
Expressions.AddRange(OperationFactory.GetExpressionList(operation.Value, container));
}
public override ExpressionSyntax VisitSimpleAssignment(ISimpleAssignmentOperation operation, Scope scope) =>
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
operation.Target.Accept(this, scope),
operation.Value.Accept(this, scope)
);
public override void VisitSimpleAssignment([NotNull] ISimpleAssignmentOperation operation)
{
base.VisitSimpleAssignment(operation);
}
