//public bool AreEqual(bool p1, bool p2)
//{
// if (p1 = p2)
// return true;
// p1 = p2;
// return p2 = p1;
//}
private void ipAssignmentIntended_CheckCodeIssues(object sender, CheckCodeIssuesEventArgs ea)
{
// Not inside the UI thread anymore.
// Don't use CodeRush.Source.Xxxxx, in fact, don't use any CodeRush.Xxxxxx is my recommendation.
ElementTypeFilter assignmentExpressionFilter = new ElementTypeFilter(LanguageElementType.AssignmentExpression);
IEnumerable <IElement> enumerable = ea.GetEnumerable(ea.Scope, assignmentExpressionFilter);
foreach (IElement element in enumerable)
{
// For every LanguageElement type, there is a corresponding interface, that starts with an I.
IAssignmentExpression assignmentExpression = element as IAssignmentExpression;
if (assignmentExpression == null)
{
continue;
}
TextPoint start = assignmentExpression.LeftSide.FirstNameRange.Start;
TextPoint end = assignmentExpression.RightSide.FirstNameRange.End;
SourceRange range = new SourceRange(start, end);
ea.AddIssue(CodeIssueType.Warning, range, cpAssignmentExpressionToEqualityCheck.CodeIssueMessage);
// Other code we were playing with...
//AssignmentExpression assignmentExpressionReal = LanguageElementRestorer.ConvertToLanguageElement(element) as AssignmentExpression;
//assignmentExpressionReal.OperatorRange
//ea.AddIssue(CodeIssueType.Warning, assignmentExpression.Range, cpAssignmentExpressionToEqualityCheck.CodeIssueMessage);
}
}
public override void VisitAssignmentExpression(IAssignmentExpression operation)
{
LogString(nameof(IAssignmentExpression));
LogCommonPropertiesAndNewLine(operation);
Visit(operation.Target, "Left");
Visit(operation.Value, "Right");
}
public override void VisitAssignmentExpression([NotNull] IAssignmentExpression operation)
{
base.VisitAssignmentExpression(operation);
if (operation.Target is ILocalReferenceExpression targetLocal && currentLocal.Equals(targetLocal.Local))
{
AnalyzeAssignmentValue(operation.Value);
}
}
public override void VisitAssignmentExpression([NotNull] IAssignmentExpression operation)
{
if (operation.Target is ILocalReferenceExpression targetLocal && local.Equals(targetLocal.Local))
{
TrySetEvent(operation.Value);
}
base.VisitAssignmentExpression(operation);
}
private void FixSpacingAroundKeywordAsExp(IAssignmentExpression item)
{
List <string> keywordSearch = new List <string> {
"new"
};
foreach (var key in keywordSearch)
{
item.Text = this.whiteSpaceHelper.RemoveWhiteSpaceAroundKeyword(item.Text, key);
}
}
public VariableFlags Assignment(
IAssignmentExpression assignmentExpression,
VariableFlags definitelyAssigned)
{
return(assignmentExpression.LeftOperand switch
{
INameExpression identifier =>
definitelyAssigned.Set(identifier.ReferencedSymbol, true),
IFieldAccessExpression _ => definitelyAssigned,
_ => throw new NotImplementedException("Complex assignments not yet implemented")
});
public override bool Visit(IAssignmentExpression expression, object context)
{
_stack.Push(expression);
try
{
return(base.Visit(expression, context));
}
finally
{
_stack.Pop();
}
}
private static bool IsStringConcatenation([NotNull] IAssignmentExpression concatenation)
{
var sourceOperand = concatenation.Source;
var destOperand = concatenation.Dest;
if (sourceOperand == null || destOperand == null)
{
return(false);
}
return(IsStringConcatOperatorReference(concatenation.OperatorReference));
}
private EventSubscriptionOperation?TryGetEventSubscriptionOperation(IAssignmentExpression expr)
{
var isRegularEq = expr.AssignmentType == AssignmentType.EQ;
if (isRegularEq)
{
return(null);
}
var refExpr = expr.Dest as IReferenceExpression;
if (refExpr == null)
{
return(null);
}
var elem = refExpr.Reference.Resolve().DeclaredElement;
if (elem == null)
{
return(null);
}
var loc = elem as ITypeOwner;
if (loc != null)
{
var type = loc.Type.GetName();
if (!type.IsDelegateType)
{
return(null);
}
}
var isAdd = expr.AssignmentType == AssignmentType.PLUSEQ;
if (isAdd)
{
return(EventSubscriptionOperation.Add);
}
var isRemove = expr.AssignmentType == AssignmentType.MINUSEQ;
if (isRemove)
{
return(EventSubscriptionOperation.Remove);
}
return(null);
}
/// <summary>
/// Remove parenthesis from node.
/// </summary>
/// <param name="node">
/// The node.
/// </param>
public static void RemoveParenthesisFromNode(ITreeNode node)
{
IParenthesizedExpression parenthesizedExpressionNode = node as IParenthesizedExpression;
if (parenthesizedExpressionNode != null)
{
using (WriteLockCookie.Create(true))
{
ICSharpExpression innerExpression = parenthesizedExpressionNode.Expression;
if (innerExpression != null && node.Parent != null)
{
NodeType innerExpressionNodeType = (innerExpression as TreeElement).NodeType;
if (innerExpressionNodeType != ElementType.ADDITIVE_EXPRESSION && innerExpressionNodeType != ElementType.MULTIPLICATIVE_EXPRESSION &&
innerExpressionNodeType != ElementType.SHIFT_EXPRESSION && innerExpressionNodeType != ElementType.AS_EXPRESSION &&
innerExpressionNodeType != ElementType.ASSIGNMENT_EXPRESSION && innerExpressionNodeType != ElementType.CAST_EXPRESSION &&
innerExpressionNodeType != ElementType.CONDITIONAL_AND_EXPRESSION && innerExpressionNodeType != ElementType.CONDITIONAL_OR_EXPRESSION &&
innerExpressionNodeType != ElementType.CONDITIONAL_TERNARY_EXPRESSION && innerExpressionNodeType != ElementType.POSTFIX_OPERATOR_EXPRESSION &&
innerExpressionNodeType != ElementType.PREFIX_OPERATOR_EXPRESSION && innerExpressionNodeType != ElementType.IS_EXPRESSION &&
innerExpressionNodeType != ElementType.LAMBDA_EXPRESSION && innerExpressionNodeType != ElementType.BITWISE_AND_EXPRESSION &&
innerExpressionNodeType != ElementType.BITWISE_INCLUSIVE_OR_EXPRESSION &&
innerExpressionNodeType != ElementType.BITWISE_EXCLUSIVE_OR_EXPRESSION && innerExpressionNodeType != ElementType.OBJECT_CREATION_EXPRESSION &&
innerExpressionNodeType != ElementType.ARRAY_CREATION_EXPRESSION && innerExpressionNodeType != ElementType.NULL_COALESCING_EXPRESSION &&
innerExpressionNodeType != ElementType.QUERY_EXPRESSION && innerExpressionNodeType != ElementType.RELATIONAL_EXPRESSION &&
innerExpressionNodeType != ElementType.UNARY_OPERATOR_EXPRESSION && innerExpressionNodeType != ElementType.EQUALITY_EXPRESSION &&
innerExpressionNodeType != ElementType.AWAIT_EXPRESSION)
{
LowLevelModificationUtil.ReplaceChildRange(node, node, new ITreeNode[] { innerExpression });
return;
}
if ((!(node.Parent is IExpression)) || node.Parent is IVariableDeclaration)
{
LowLevelModificationUtil.ReplaceChildRange(node, node, new ITreeNode[] { innerExpression });
return;
}
IAssignmentExpression parent = node.Parent as IAssignmentExpression;
if (parent != null && parent.Source == node)
{
LowLevelModificationUtil.ReplaceChildRange(node, node, new ITreeNode[] { innerExpression });
return;
}
}
}
}
}
public override void VisitAssignmentExpression(IAssignmentExpression expr, IList <IStatement> body)
{
if (IsTargetMatch(expr, CompletionCase.EmptyCompletionBefore))
{
body.Add(EmptyCompletionExpression);
}
var isTarget = IsTargetMatch(expr, CompletionCase.InBody);
var sstRef = _exprVisitor.ToAssignableRef(expr.Dest, body) ?? new UnknownReference();
var sstExpr =
isTarget
? new CompletionExpression()
: _exprVisitor.ToAssignableExpr(expr.Source, body);
var operation = TryGetEventSubscriptionOperation(expr);
if (operation.HasValue)
{
body.Add(
new EventSubscriptionStatement
{
Reference = sstRef,
Operation = operation.Value,
Expression = sstExpr
});
}
else
{
if (!IsSelfAssign(sstRef, sstExpr))
{
body.Add(
new Assignment
{
Reference = sstRef,
Expression = IsFancyAssign(expr) ? new ComposedExpression() : sstExpr
});
}
}
if (IsTargetMatch(expr, CompletionCase.EmptyCompletionAfter))
{
body.Add(EmptyCompletionExpression);
}
}
private bool IsInvocationInternal()
{
var parent = Node.Parent;
while (parent != null)
{
if (parent == AnalyzeUnit.Node)
{
return(false);
}
if (parent is IAssignmentExpression ||
parent is ICSharpArgument ||
parent is IExpressionInitializer ||
parent is IAccessorDeclaration)
{
var property = Node.Reference.Resolve().DeclaredElement as IProperty;
if (parent is IAssignmentExpression)
{
_assignment = (IAssignmentExpression)parent;
}
if (property != null)
{
var psiModule = Node.GetPsiModule();
#if R10
var delegateType = TypeFactory.CreateTypeByCLRName("System.Delegate", psiModule);
#else
var delegateType = TypeFactory.CreateTypeByCLRName("System.Delegate", psiModule, psiModule.GetContextFromModule());
#endif
return(!property.Type.IsSubtypeOf(delegateType));
}
return(false);
}
if (parent is IElementAccessExpression ||
parent is IInvocationExpression)
{
return(true);
}
parent = parent.Parent;
}
return(false);
}
public VariableFlags Assignment(
IAssignmentExpression assignmentExpression,
VariableFlags possiblyMoved)
{
switch (assignmentExpression.LeftOperand)
{
case INameExpression identifierName:
// We are assigning into this variable so it definitely has a value now
var symbol = identifierName.ReferencedSymbol;
return(possiblyMoved.Set(symbol, false));
case IFieldAccessExpression _:
return(possiblyMoved);
default:
throw new NotImplementedException("Complex assignments not yet implemented");
}
}
public VariableFlags Assignment(
IAssignmentExpression assignmentExpression,
VariableFlags liveVariables)
{
switch (assignmentExpression.LeftOperand)
{
case INameExpression identifier:
var symbol = identifier.ReferencedSymbol;
var isLifeAfter = liveVariables[symbol]
?? throw new Exception($"No liveness data for variable {symbol}");
identifier.VariableIsLiveAfter.Fulfill(isLifeAfter);
return(liveVariables.Set(symbol, false));
case IFieldAccessExpression _:
return(liveVariables);
default:
throw new NotImplementedException("Complex assignments not yet implemented");
}
}
private static bool IsParameterReferenceOrCoalesceOfParameterReference(
IAssignmentExpression assignmentExpression, IParameterSymbol parameter)
{
if (IsParameterReference(assignmentExpression.Value, parameter))
{
// We already have a member initialized with this parameter like:
// this.field = parameter
return(true);
}
if (UnwrapImplicitConversion(assignmentExpression.Value) is INullCoalescingExpression coalesceExpression &&
IsParameterReference(coalesceExpression.PrimaryOperand, parameter))
{
// We already have a member initialized with this parameter like:
// this.field = parameter ?? ...
return(true);
}
return(false);
}
public VariableFlags Assignment(
IAssignmentExpression assignmentExpression,
VariableFlags definitelyUnassigned)
{
switch (assignmentExpression.LeftOperand)
{
case INameExpression identifier:
var symbol = identifier.ReferencedSymbol;
if (!symbol.IsMutableBinding && definitelyUnassigned[symbol] == false)
{
diagnostics.Add(SemanticError.VariableMayAlreadyBeAssigned(file, identifier.Span, identifier.ReferencedSymbol.Name));
}
return(definitelyUnassigned.Set(symbol, false));
case IFieldAccessExpression _:
return(definitelyUnassigned);
default:
throw new NotImplementedException("Complex assignments not yet implemented");
}
}
public static bool IsPropertyAssignment(IAssignmentExpression expression, out IProperty property)
{
property = null;
try
{
var referenceExpression = expression.Dest as IReferenceExpression;
if (referenceExpression == null)
{
return false;
}
var result = referenceExpression.Reference.Resolve().Result;
property = result.DeclaredElement as IProperty;
return property != null;
}
catch (Exception exn)
{
Debug.WriteLine(exn);
return false;
}
}
private bool TryFindAssignmentExpression(
IBlockStatement containingBlock, IIfStatement ifOperation, ISymbol localOrParameter,
out IExpressionStatement expressionStatement, out IAssignmentExpression assignmentExpression)
{
var ifOperationIndex = containingBlock.Statements.IndexOf(ifOperation);
// walk forward until we find an assignment of this local/parameter into
// something else.
for (var i = ifOperationIndex + 1; i < containingBlock.Statements.Length; i++)
{
expressionStatement = containingBlock.Statements[i] as IExpressionStatement;
if (expressionStatement == null)
{
continue;
}
assignmentExpression = expressionStatement.Expression as IAssignmentExpression;
if (assignmentExpression == null)
{
continue;
}
ISymbol assignmentValue;
if (!TryGetLocalOrParameterSymbol(assignmentExpression.Value, out assignmentValue))
{
continue;
}
if (!Equals(localOrParameter, assignmentValue))
{
continue;
}
return(true);
}
expressionStatement = null;
assignmentExpression = null;
return(false);
}
/// <summary>Inserts the assertion code.</summary>
/// <param name="assignmentExpression">The assignment expression.</param>
private void InsertAssertionCode(IAssignmentExpression assignmentExpression)
{
var destination = assignmentExpression.Dest;
if (destination == null)
{
return;
}
if (!destination.IsClassifiedAsVariable)
{
return;
}
var type = destination.GetExpressionType() as IType;
if (type == null)
{
return;
}
var referenceExpression = assignmentExpression.Dest as IReferenceExpression;
if (referenceExpression == null)
{
return;
}
this.InsertAssertionCode(type, assignmentExpression, referenceExpression.Reference.GetName());
}
public virtual void VisitAssignmentExpression(IAssignmentExpression operation)
{
DefaultVisit(operation);
}
private bool TryFindAssignmentExpression(
IBlockStatement containingBlock, IIfStatement ifOperation, ISymbol localOrParameter,
out IExpressionStatement expressionStatement, out IAssignmentExpression assignmentExpression)
{
var ifOperationIndex = containingBlock.Statements.IndexOf(ifOperation);
// walk forward until we find an assignment of this local/parameter into
// something else.
for (var i = ifOperationIndex + 1; i < containingBlock.Statements.Length; i++)
{
expressionStatement = containingBlock.Statements[i] as IExpressionStatement;
if (expressionStatement == null)
{
continue;
}
assignmentExpression = expressionStatement.Expression as IAssignmentExpression;
if (assignmentExpression == null)
{
continue;
}
if (!TryGetLocalOrParameterSymbol(assignmentExpression.Value, out var assignmentValue))
{
continue;
}
if (!Equals(localOrParameter, assignmentValue))
{
continue;
}
return true;
}
expressionStatement = null;
assignmentExpression = null;
return false;
}
private void FixSpacingAroundKeywordAsExp(IAssignmentExpression item)
{
List<string> keywordSearch = new List<string> { "new" };
foreach (var key in keywordSearch)
{
item.Text = this.whiteSpaceHelper.RemoveWhiteSpaceAroundKeyword(item.Text, key);
}
}
public virtual void VisitAssignmentExpression(IAssignmentExpression operation)
{
DefaultVisit(operation);
}
private void AnalyzeXmlTextReaderProperties(OperationAnalysisContext context, ISymbol assignedSymbol, IAssignmentExpression expression, bool isXmlTextReaderXmlResolverProperty, bool isXmlTextReaderDtdProcessingProperty)
{
XmlTextReaderEnvironment env;
if (!_xmlTextReaderEnvironments.TryGetValue(assignedSymbol, out env))
{
env = new XmlTextReaderEnvironment(_isFrameworkSecure);
}
if (isXmlTextReaderXmlResolverProperty)
{
env.IsXmlResolverSet = true;
}
else
{
env.IsDtdProcessingSet = true;
}
IConversionExpression conv = expression.Value as IConversionExpression;
if (isXmlTextReaderXmlResolverProperty && conv != null && SecurityDiagnosticHelpers.IsXmlSecureResolverType(conv.Operand.Type, _xmlTypes))
{
env.IsSecureResolver = true;
}
else if (isXmlTextReaderXmlResolverProperty && conv != null && SecurityDiagnosticHelpers.IsExpressionEqualsNull(conv.Operand))
{
env.IsSecureResolver = true;
}
else if (isXmlTextReaderDtdProcessingProperty && conv == null && !SecurityDiagnosticHelpers.IsExpressionEqualsDtdProcessingParse(expression.Value))
{
env.IsDtdProcessingDisabled = !SecurityDiagnosticHelpers.IsExpressionEqualsDtdProcessingParse(expression.Value);
}
else
{
// Generate a warning whenever the XmlResolver or DtdProcessing property is set to an insecure value
Diagnostic diag = Diagnostic.Create(
RuleDoNotUseInsecureDtdProcessing,
expression.Syntax.GetLocation(),
SecurityDiagnosticHelpers.GetLocalizableResourceString(
nameof(DesktopAnalyzersResources.XmlTextReaderSetInsecureResolutionMessage)
)
);
context.ReportDiagnostic(diag);
}
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterOperationBlockStartAction(
(operationBlockContext) =>
{
IMethodSymbol containingMethod = operationBlockContext.OwningSymbol as IMethodSymbol;
if (containingMethod != null)
{
HashSet <ILocalSymbol> mightBecomeConstLocals = new HashSet <ILocalSymbol>();
HashSet <ILocalSymbol> assignedToLocals = new HashSet <ILocalSymbol>();
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IAssignmentExpression assignment = (IAssignmentExpression)operationContext.Operation;
AssignTo(assignment.Target, assignedToLocals, mightBecomeConstLocals);
},
OperationKind.AssignmentExpression,
OperationKind.CompoundAssignmentExpression,
OperationKind.IncrementExpression);
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IInvocationExpression invocation = (IInvocationExpression)operationContext.Operation;
foreach (IArgument argument in invocation.ArgumentsInParameterOrder)
{
if (argument.Parameter.RefKind == RefKind.Out || argument.Parameter.RefKind == RefKind.Ref)
{
AssignTo(argument.Value, assignedToLocals, mightBecomeConstLocals);
}
}
},
OperationKind.InvocationExpression);
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IVariableDeclarationStatement declaration = (IVariableDeclarationStatement)operationContext.Operation;
foreach (IVariable variable in declaration.Variables)
{
ILocalSymbol local = variable.Variable;
if (!local.IsConst && !assignedToLocals.Contains(local))
{
var localType = local.Type;
if ((!localType.IsReferenceType || localType.SpecialType == SpecialType.System_String) && localType.SpecialType != SpecialType.None)
{
if (variable.InitialValue != null && variable.InitialValue.ConstantValue.HasValue)
{
mightBecomeConstLocals.Add(local);
}
}
}
}
},
OperationKind.VariableDeclarationStatement);
operationBlockContext.RegisterOperationBlockEndAction(
(operationBlockEndContext) =>
{
foreach (ILocalSymbol couldBeConstLocal in mightBecomeConstLocals)
{
Report(operationBlockEndContext, couldBeConstLocal, LocalCouldBeConstDescriptor);
}
});
}
});
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterCompilationStartAction(
(compilationContext) =>
{
HashSet <IFieldSymbol> assignedToFields = new HashSet <IFieldSymbol>();
HashSet <IFieldSymbol> mightBecomeReadOnlyFields = new HashSet <IFieldSymbol>();
compilationContext.RegisterOperationBlockStartAction(
(operationBlockContext) =>
{
IMethodSymbol containingMethod = operationBlockContext.OwningSymbol as IMethodSymbol;
if (containingMethod != null)
{
bool inConstructor = containingMethod.MethodKind == MethodKind.Constructor;
ITypeSymbol staticConstructorType = containingMethod.MethodKind == MethodKind.StaticConstructor ? containingMethod.ContainingType : null;
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IAssignmentExpression assignment = (IAssignmentExpression)operationContext.Operation;
AssignTo(assignment.Target, inConstructor, staticConstructorType, assignedToFields, mightBecomeReadOnlyFields);
},
OperationKind.AssignmentExpression,
OperationKind.CompoundAssignmentExpression,
OperationKind.IncrementExpression);
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IInvocationExpression invocation = (IInvocationExpression)operationContext.Operation;
foreach (IArgument argument in invocation.ArgumentsInParameterOrder)
{
if (argument.Parameter.RefKind == RefKind.Out || argument.Parameter.RefKind == RefKind.Ref)
{
AssignTo(argument.Value, inConstructor, staticConstructorType, assignedToFields, mightBecomeReadOnlyFields);
}
}
},
OperationKind.InvocationExpression);
}
});
compilationContext.RegisterSymbolAction(
(symbolContext) =>
{
IFieldSymbol field = (IFieldSymbol)symbolContext.Symbol;
if (!field.IsConst && !field.IsReadOnly && !assignedToFields.Contains(field))
{
mightBecomeReadOnlyFields.Add(field);
}
},
SymbolKind.Field
);
compilationContext.RegisterCompilationEndAction(
(compilationEndContext) =>
{
foreach (IFieldSymbol couldBeReadOnlyField in mightBecomeReadOnlyFields)
{
Report(compilationEndContext, couldBeReadOnlyField, FieldCouldBeReadOnlyDescriptor);
}
});
});
}
private void AnalyzeAssignment(OperationAnalysisContext context)
{
IAssignmentExpression expression = context.Operation as IAssignmentExpression;
if (expression.Target == null)
{
return;
}
SemanticModel model = context.Compilation.GetSemanticModel(expression.Syntax.SyntaxTree);
var propRef = expression.Target as IPropertyReferenceExpression;
if (propRef == null) // A variable/field assignment
{
ISymbol symbolAssignedTo = expression.Target.Syntax.GetDeclaredOrReferencedSymbol(model);
if (symbolAssignedTo != null)
{
AnalyzeObjectCreationInternal(context, symbolAssignedTo, expression.Value);
}
}
else // A property assignment
{
ISymbol assignedSymbol = propRef.Instance.Syntax.GetDeclaredOrReferencedSymbol(model);
if (propRef.Property.MatchPropertyByName(_xmlTypes.XmlDocument, "XmlResolver"))
{
AnalyzeXmlResolverPropertyAssignmentForXmlDocument(context, assignedSymbol, expression);
}
else
{
bool isXmlTextReaderXmlResolverProperty = SecurityDiagnosticHelpers.IsXmlTextReaderXmlResolverPropertyDerived(propRef.Property, _xmlTypes);
bool isXmlTextReaderDtdProcessingProperty = !isXmlTextReaderXmlResolverProperty &&
SecurityDiagnosticHelpers.IsXmlTextReaderDtdProcessingPropertyDerived(propRef.Property, _xmlTypes);
if (isXmlTextReaderXmlResolverProperty || isXmlTextReaderDtdProcessingProperty)
{
AnalyzeXmlTextReaderProperties(context, assignedSymbol, expression, isXmlTextReaderXmlResolverProperty, isXmlTextReaderDtdProcessingProperty);
}
else if (SecurityDiagnosticHelpers.IsXmlReaderSettingsType(propRef.Instance.Type, _xmlTypes))
{
XmlReaderSettingsEnvironment env;
if (!_xmlReaderSettingsEnvironments.TryGetValue(assignedSymbol, out env))
{
env = new XmlReaderSettingsEnvironment(_isFrameworkSecure);
_xmlReaderSettingsEnvironments[assignedSymbol] = env;
}
IConversionExpression conv = expression.Value as IConversionExpression;
if (conv != null && SecurityDiagnosticHelpers.IsXmlReaderSettingsXmlResolverProperty(
propRef.Property,
_xmlTypes)
)
{
if (SecurityDiagnosticHelpers.IsXmlSecureResolverType(conv.Operand.Type, _xmlTypes))
{
env.IsSecureResolver = true;
}
else if (SecurityDiagnosticHelpers.IsExpressionEqualsNull(conv.Operand))
{
env.IsSecureResolver = true;
}
}
else if (SecurityDiagnosticHelpers.IsXmlReaderSettingsDtdProcessingProperty(propRef.Property, _xmlTypes))
{
env.IsDtdProcessingDisabled = !SecurityDiagnosticHelpers.IsExpressionEqualsDtdProcessingParse(expression.Value);
}
else if (SecurityDiagnosticHelpers.IsXmlReaderSettingsMaxCharactersFromEntitiesProperty(propRef.Property, _xmlTypes))
{
env.IsMaxCharactersFromEntitiesLimited = !SecurityDiagnosticHelpers.IsExpressionEqualsIntZero(expression.Value);
}
}
else
{
AnalyzeNeverSetProperties(context, propRef.Property, expression.Syntax.GetLocation());
}
}
}
}
void IExpressionVisitor.Visit(IAssignmentExpression expression)
{
this.Translate(expression);
}
private static bool ValueIsAccessed(SemanticModel semanticModel, IIfStatement ifOperation, IBlockStatement containingBlock, ISymbol localOrParameter, IExpressionStatement expressionStatement, IAssignmentExpression assignmentExpression)
{
var statements = containingBlock.Statements;
var ifOperationIndex = statements.IndexOf(ifOperation);
var expressionStatementIndex = statements.IndexOf(expressionStatement);
if (expressionStatementIndex > ifOperationIndex + 1)
{
// There are intermediary statements between the check and the assignment.
// Make sure they don't try to access the local.
var dataFlow = semanticModel.AnalyzeDataFlow(
statements[ifOperationIndex + 1].Syntax,
statements[expressionStatementIndex - 1].Syntax);
if (dataFlow.ReadInside.Contains(localOrParameter) ||
dataFlow.WrittenInside.Contains(localOrParameter))
{
return(true);
}
}
// Also, have to make sure there is no read/write of the local/parameter on the left
// of the assignment. For example: map[val.Id] = val;
var exprDataFlow = semanticModel.AnalyzeDataFlow(assignmentExpression.Target.Syntax);
return(exprDataFlow.ReadInside.Contains(localOrParameter) ||
exprDataFlow.WrittenInside.Contains(localOrParameter));
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterCompilationStartAction(
(compilationContext) =>
{
Dictionary <IFieldSymbol, HashSet <INamedTypeSymbol> > fieldsSourceTypes = new Dictionary <IFieldSymbol, HashSet <INamedTypeSymbol> >();
compilationContext.RegisterOperationBlockStartAction(
(operationBlockContext) =>
{
if (operationBlockContext.OwningSymbol is IMethodSymbol containingMethod)
{
Dictionary <ILocalSymbol, HashSet <INamedTypeSymbol> > localsSourceTypes = new Dictionary <ILocalSymbol, HashSet <INamedTypeSymbol> >();
// Track explicit assignments.
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IAssignmentExpression assignment = (IAssignmentExpression)operationContext.Operation;
AssignTo(assignment.Target, localsSourceTypes, fieldsSourceTypes, assignment.Value);
},
OperationKind.AssignmentExpression,
OperationKind.CompoundAssignmentExpression,
OperationKind.IncrementExpression);
// Track arguments that match out or ref parameters.
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IInvocationExpression invocation = (IInvocationExpression)operationContext.Operation;
foreach (IArgument argument in invocation.ArgumentsInEvaluationOrder)
{
if (argument.Parameter.RefKind == RefKind.Out || argument.Parameter.RefKind == RefKind.Ref)
{
AssignTo(argument.Value, localsSourceTypes, fieldsSourceTypes, argument.Parameter.Type);
}
}
},
OperationKind.InvocationExpression);
// Track local variable initializations.
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IVariableDeclarationStatement declaration = (IVariableDeclarationStatement)operationContext.Operation;
foreach (IVariableDeclaration variable in declaration.Declarations)
{
foreach (ILocalSymbol local in variable.Variables)
{
if (variable.Initializer != null)
{
AssignTo(local, local.Type, localsSourceTypes, variable.Initializer);
}
}
}
},
OperationKind.VariableDeclarationStatement);
// Report locals that could have more specific types.
operationBlockContext.RegisterOperationBlockEndAction(
(operationBlockEndContext) =>
{
foreach (ILocalSymbol local in localsSourceTypes.Keys)
{
if (HasMoreSpecificSourceType(local, local.Type, localsSourceTypes, out var mostSpecificSourceType))
{
Report(operationBlockEndContext, local, mostSpecificSourceType, LocalCouldHaveMoreSpecificTypeDescriptor);
}
}
});
}
});
// Track field initializations.
compilationContext.RegisterOperationAction(
(operationContext) =>
{
IFieldInitializer initializer = (IFieldInitializer)operationContext.Operation;
foreach (IFieldSymbol initializedField in initializer.InitializedFields)
{
AssignTo(initializedField, initializedField.Type, fieldsSourceTypes, initializer.Value);
}
},
OperationKind.FieldInitializerAtDeclaration);
// Report fields that could have more specific types.
compilationContext.RegisterCompilationEndAction(
(compilationEndContext) =>
{
foreach (IFieldSymbol field in fieldsSourceTypes.Keys)
{
if (HasMoreSpecificSourceType(field, field.Type, fieldsSourceTypes, out var mostSpecificSourceType))
{
Report(compilationEndContext, field, mostSpecificSourceType, FieldCouldHaveMoreSpecificTypeDescriptor);
}
}
});
});
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterOperationAction(
(operationContext) =>
{
ILoopStatement loop = (ILoopStatement)operationContext.Operation;
if (loop.LoopKind == LoopKind.For)
{
IForLoopStatement forLoop = (IForLoopStatement)loop;
IExpression forCondition = forLoop.Condition;
if (forCondition.Kind == OperationKind.BinaryOperatorExpression)
{
IBinaryOperatorExpression condition = (IBinaryOperatorExpression)forCondition;
IExpression conditionLeft = condition.Left;
IExpression conditionRight = condition.Right;
if (conditionRight.ConstantValue != null &&
conditionRight.ResultType.SpecialType == SpecialType.System_Int32 &&
conditionLeft.Kind == OperationKind.LocalReferenceExpression)
{
// Test is known to be a comparison of a local against a constant.
int testValue = (int)conditionRight.ConstantValue;
ILocalSymbol testVariable = ((ILocalReferenceExpression)conditionLeft).Local;
if (forLoop.Before.Length == 1)
{
IStatement setup = forLoop.Before[0];
if (setup.Kind == OperationKind.ExpressionStatement && ((IExpressionStatement)setup).Expression.Kind == OperationKind.AssignmentExpression)
{
IAssignmentExpression setupAssignment = (IAssignmentExpression)((IExpressionStatement)setup).Expression;
if (setupAssignment.Target.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)setupAssignment.Target).Local == testVariable &&
setupAssignment.Value.ConstantValue != null &&
setupAssignment.Value.ResultType.SpecialType == SpecialType.System_Int32)
{
// Setup is known to be an assignment of a constant to the local used in the test.
int initialValue = (int)setupAssignment.Value.ConstantValue;
if (forLoop.AtLoopBottom.Length == 1)
{
IStatement advance = forLoop.AtLoopBottom[0];
if (advance.Kind == OperationKind.ExpressionStatement)
{
IExpression advanceExpression = ((IExpressionStatement)advance).Expression;
IExpression advanceIncrement = null;
BinaryOperationKind advanceOperationCode = BinaryOperationKind.None;
if (advanceExpression.Kind == OperationKind.AssignmentExpression)
{
IAssignmentExpression advanceAssignment = (IAssignmentExpression)advanceExpression;
if (advanceAssignment.Target.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)advanceAssignment.Target).Local == testVariable &&
advanceAssignment.Value.Kind == OperationKind.BinaryOperatorExpression &&
advanceAssignment.Value.ResultType.SpecialType == SpecialType.System_Int32)
{
// Advance is known to be an assignment of a binary operation to the local used in the test.
IBinaryOperatorExpression advanceOperation = (IBinaryOperatorExpression)advanceAssignment.Value;
if (!advanceOperation.UsesOperatorMethod &&
advanceOperation.Left.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)advanceOperation.Left).Local == testVariable &&
advanceOperation.Right.ConstantValue != null &&
advanceOperation.Right.ResultType.SpecialType == SpecialType.System_Int32)
{
// Advance binary operation is known to involve a reference to the local used in the test and a constant.
advanceIncrement = advanceOperation.Right;
advanceOperationCode = advanceOperation.BinaryKind;
}
}
}
else if (advanceExpression.Kind == OperationKind.CompoundAssignmentExpression || advanceExpression.Kind == OperationKind.IncrementExpression)
{
ICompoundAssignmentExpression advanceAssignment = (ICompoundAssignmentExpression)advanceExpression;
if (advanceAssignment.Target.Kind == OperationKind.LocalReferenceExpression &&
((ILocalReferenceExpression)advanceAssignment.Target).Local == testVariable &&
advanceAssignment.Value.ConstantValue != null &&
advanceAssignment.Value.ResultType.SpecialType == SpecialType.System_Int32)
{
// Advance binary operation is known to involve a reference to the local used in the test and a constant.
advanceIncrement = advanceAssignment.Value;
advanceOperationCode = advanceAssignment.BinaryKind;
}
}
if (advanceIncrement != null)
{
int incrementValue = (int)advanceIncrement.ConstantValue;
if (advanceOperationCode == BinaryOperationKind.IntegerSubtract)
{
advanceOperationCode = BinaryOperationKind.IntegerAdd;
incrementValue = -incrementValue;
}
if (advanceOperationCode == BinaryOperationKind.IntegerAdd &&
incrementValue != 0 &&
(condition.BinaryKind == BinaryOperationKind.IntegerLessThan ||
condition.BinaryKind == BinaryOperationKind.IntegerLessThanOrEqual ||
condition.BinaryKind == BinaryOperationKind.IntegerNotEquals ||
condition.BinaryKind == BinaryOperationKind.IntegerGreaterThan ||
condition.BinaryKind == BinaryOperationKind.IntegerGreaterThanOrEqual))
{
int iterationCount = (testValue - initialValue) / incrementValue;
if (iterationCount >= 1000000)
{
Report(operationContext, forLoop.Syntax, BigForDescriptor);
}
}
}
}
}
}
}
}
}
}
}
},
OperationKind.LoopStatement);
}
public override void VisitAssignmentExpression(IAssignmentExpression operation)
{
base.VisitAssignmentExpression(operation);
}
TransformationImpact IExpressionVisitor <TransformationImpact> .Visit(IAssignmentExpression expression)
{
return(CalculateRefactorImpact(expression));
}
public override void VisitAssignmentExpression(IAssignmentExpression operation)
{
Visit(operation.Target);
Visit(operation.Value);
}
public AssignmentExpressionCompiler(IAssignmentExpression assignmentExpression, AbstractILCompilerParams @params) : base(@params)
{
myAssignmentExpression = assignmentExpression;
}
private void AnalyzeXmlResolverPropertyAssignmentForXmlDocument(OperationAnalysisContext context, ISymbol assignedSymbol, IAssignmentExpression expression)
{
bool isSecureResolver = false;
IConversionExpression conv = expression.Value as IConversionExpression;
if (SecurityDiagnosticHelpers.IsXmlSecureResolverType(conv.Operand.Type, _xmlTypes))
{
isSecureResolver = true;
}
else if (conv != null && SecurityDiagnosticHelpers.IsExpressionEqualsNull(conv.Operand))
{
isSecureResolver = true;
}
else // Assigning XmlDocument's XmlResolver to an insecure value
{
Diagnostic diag = Diagnostic.Create(
RuleDoNotUseInsecureDtdProcessing,
context.Operation.Syntax.GetLocation(),
SecurityDiagnosticHelpers.GetLocalizableResourceString(
nameof(DesktopAnalyzersResources.XmlDocumentWithNoSecureResolverMessage)
)
);
context.ReportDiagnostic(diag);
}
if (_xmlDocumentEnvironments.ContainsKey(assignedSymbol))
{
XmlDocumentEnvironment xmlDocumentEnv = _xmlDocumentEnvironments[assignedSymbol];
xmlDocumentEnv.IsXmlResolverSet = true;
xmlDocumentEnv.IsSecureResolver = isSecureResolver;
}
}
public abstract IExpression Transform(IAssignmentExpression expression);
public static IAssignmentExpression Update(this IAssignmentExpression self, IOperation @left, IOperation @right, RefKind @refKind, ITypeSymbol @type) => self;
/// <summary>
/// Inserts the assertion code.
/// </summary>
/// <param name="assignmentExpression">
/// The assignment expression.
/// </param>
private void CheckAssignment(IAssignmentExpression assignmentExpression)
{
var destination = assignmentExpression.Dest;
if (destination == null)
{
return;
}
if (!destination.IsClassifiedAsVariable)
{
return;
}
var type = destination.GetExpressionType() as IType;
if (type == null)
{
return;
}
var referenceExpression = assignmentExpression.Dest as IReferenceExpression;
if (referenceExpression == null)
{
return;
}
var anchor = assignmentExpression.GetContainingStatement();
this.CheckAssignment(assignmentExpression, anchor, referenceExpression.Reference.GetName());
}
public static bool IsSourceAssignmentAsObservable(IAssignmentExpression expression)
{
try
{
var invocationExpression = expression.Source as IInvocationExpression;
if (invocationExpression == null)
{
return false;
}
var invokedExpression = invocationExpression.InvokedExpression as IReferenceExpression;
if (invokedExpression == null)
{
return false;
}
var resolveResult = invokedExpression.Reference.Resolve();
var declaredElement = resolveResult.DeclaredElement;
if (declaredElement == null)
{
return false;
}
return declaredElement.ShortName == Constants.AsObservableName;
}
catch (Exception exn)
{
Debug.WriteLine(exn);
return false;
}
}
