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