public VariableFlags VariableDeclaration(
IVariableDeclarationStatement variableDeclaration,
VariableFlags possiblyMoved)
{
// No affect on state since it should already be false
return(possiblyMoved);
}
public virtual void VisitVariableDeclarationStatement <TTypeReference, TExpression>(
IVariableDeclarationStatement <TTypeReference, TExpression> variableDeclarationStatement)
where TTypeReference : ITypeReference
where TExpression : IExpression
{
Visit(variableDeclarationStatement);
}
public VariableFlags VariableDeclaration(
IVariableDeclarationStatement variableDeclaration,
VariableFlags liveVariables)
{
SetLiveness(variableDeclaration.Symbol, variableDeclaration.VariableIsLiveAfter, liveVariables);
return(liveVariables.Set(variableDeclaration.Symbol, false));
}
public VariableBindingScope(BindingScope containingScope,
IVariableDeclarationStatement variableDeclaration)
{
ContainingScope = containingScope;
VariableBinding = new VariableBinding(variableDeclaration);
ContainingScope.NestedBindingDeclared(VariableBinding);
}
public override void VisitVariableDeclarationStatement <TTypeReference, TExpression>(
IVariableDeclarationStatement <TTypeReference, TExpression> variableDeclarationStatement)
{
Value = new Statement()
{
VariableDeclarationStatement = new VariableDeclarationStatementFactory(variableDeclarationStatement).Value
};
}
public override void VisitVariableDeclarationStatement(IVariableDeclarationStatement operation)
{
var variablesCountStr = $"{operation.Variables.Length} variables";
LogString($"{nameof(IVariableDeclarationStatement)} ({variablesCountStr})");
LogCommonPropertiesAndNewLine(operation);
base.VisitVariableDeclarationStatement(operation);
}
public VariableFlags VariableDeclaration(
IVariableDeclarationStatement variableDeclaration,
VariableFlags definitelyUnassigned)
{
if (variableDeclaration.Initializer is null)
{
return(definitelyUnassigned);
}
return(definitelyUnassigned.Set(variableDeclaration.Symbol, false));
}
public Variable?AddVariable(IVariableDeclarationStatement variableDeclaration)
{
var referenceType = variableDeclaration.Symbol.DataType.Known().UnderlyingReferenceType();
if (referenceType is null)
{
return(null);
}
return(ReferenceGraph.AddVariable(variableDeclaration.Symbol));
}
public override void VisitVariableDeclarationStatement([NotNull] IVariableDeclarationStatement operation)
{
base.VisitVariableDeclarationStatement(operation);
foreach (IVariableDeclaration variable in operation.Declarations)
{
if (currentLocal.Equals(variable.Variables.Single()))
{
AnalyzeAssignmentValue(variable.Initializer);
}
}
}
public static ImmutableArray <ILocalSymbol> GetDeclaredVariables(this IVariableDeclarationStatement declarationStatement)
{
var arrayBuilder = ArrayBuilder <ILocalSymbol> .GetInstance();
foreach (IVariableDeclaration group in declarationStatement.Declarations)
{
foreach (ILocalSymbol symbol in group.Variables)
{
arrayBuilder.Add(symbol);
}
}
return(arrayBuilder.ToImmutableAndFree());
}
public static ImmutableArray <ILocalSymbol> GetDeclaredVariables(this IVariableDeclarationStatement declarationStatement)
{
if (declarationStatement == null)
{
throw new ArgumentNullException(nameof(declarationStatement));
}
var arrayBuilder = ArrayBuilder <ILocalSymbol> .GetInstance();
foreach (IVariableDeclaration group in declarationStatement.Declarations)
{
foreach (ILocalSymbol symbol in group.Variables)
{
arrayBuilder.Add(symbol);
}
}
return(arrayBuilder.ToImmutableAndFree());
}
public override void VisitVariableDeclarationStatement(IVariableDeclarationStatement operation)
{
base.VisitVariableDeclarationStatement(operation);
}
public override void VisitVariableDeclarationStatement(IVariableDeclarationStatement operation)
{
VisitArray(operation.Variables);
}
public static IVariableDeclarationStatement Update(this IVariableDeclarationStatement self, ImmutableArray <IOperation> @localDeclarations) => self;
public static IVariableDeclarationStatement Update(this IVariableDeclarationStatement self, ILocalSymbol @localSymbol, IOperation @declaredType, IOperation @initializerOpt, ImmutableArray <IOperation> @argumentsOpt) => self;
public static IUsingStatement Update(this IUsingStatement self, ImmutableArray <ISymbol> @locals, IVariableDeclarationStatement @declarationsOpt, IOperation @expressionOpt, Conversion @iDisposableConversion, IOperation @body) => self;
public static IFixedStatement Update(this IFixedStatement self, ImmutableArray <ISymbol> @locals, IVariableDeclarationStatement @declarations, IOperation @body) => self;
public override IOperation VisitVariableDeclarationStatement(IVariableDeclarationStatement operation, object argument)
{
return(new VariableDeclarationStatement(VisitArray(operation.Declarations), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public override void VisitVariableDeclarationStatement(IVariableDeclarationStatement operation)
{
base.VisitVariableDeclarationStatement(operation);
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterOperationBlockStartAction(
(operationBlockContext) =>
{
if (operationBlockContext.OwningSymbol is IMethodSymbol containingMethod)
{
HashSet <ILocalSymbol> mightBecomeConstLocals = new HashSet <ILocalSymbol>();
HashSet <ILocalSymbol> assignedToLocals = new HashSet <ILocalSymbol>();
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
if (operationContext.Operation is IAssignmentExpression assignment)
{
AssignTo(assignment.Target, assignedToLocals, mightBecomeConstLocals);
}
else if (operationContext.Operation is IIncrementOrDecrementExpression increment)
{
AssignTo(increment.Target, assignedToLocals, mightBecomeConstLocals);
}
else
{
throw TestExceptionUtilities.UnexpectedValue(operationContext.Operation);
}
},
OperationKind.SimpleAssignmentExpression,
OperationKind.CompoundAssignmentExpression,
OperationKind.IncrementExpression);
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, assignedToLocals, mightBecomeConstLocals);
}
}
},
OperationKind.InvocationExpression);
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IVariableDeclarationStatement declaration = (IVariableDeclarationStatement)operationContext.Operation;
foreach (IVariableDeclaration variable in declaration.Declarations)
{
foreach (ILocalSymbol local in variable.Variables)
{
if (!local.IsConst && !assignedToLocals.Contains(local))
{
var localType = local.Type;
if ((!localType.IsReferenceType || localType.SpecialType == SpecialType.System_String) && localType.SpecialType != SpecialType.None)
{
if (variable.Initializer != null && variable.Initializer.Value.ConstantValue.HasValue)
{
mightBecomeConstLocals.Add(local);
}
}
}
}
}
},
OperationKind.VariableDeclarationStatement);
operationBlockContext.RegisterOperationBlockEndAction(
(operationBlockEndContext) =>
{
foreach (ILocalSymbol couldBeConstLocal in mightBecomeConstLocals)
{
Report(operationBlockEndContext, couldBeConstLocal, LocalCouldBeConstDescriptor);
}
});
}
});
}
public virtual void VisitVariableDeclarationStatement(IVariableDeclarationStatement s)
{
}
/// <inheritdoc />
public override IOperation VisitVariableDeclarationStatement(IVariableDeclarationStatement operation, object argument)
{
return(operation.Update(VisitList(operation.Variables).As <IOperation>()));
}
/// <inheritdoc />
public override Expression VisitVariableDeclarationStatement(IVariableDeclarationStatement operation, LocalBinder argument)
{
return(Expression.Block(operation.Variables.Select(x => x.Accept(this, argument))));
}
public virtual void VisitVariableDeclarationStatement(IVariableDeclarationStatement operation)
{
DefaultVisit(operation);
}
public virtual void VisitVariableDeclarationStatement(IVariableDeclarationStatement operation)
{
DefaultVisit(operation);
}
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 override void VisitVariableDeclarationStatement <TTypeReference, TExpression>(
IVariableDeclarationStatement <TTypeReference, TExpression> variableDeclarationStatement)
{
Steps.Add(new WriteChildNode <TTypeReference>(variableDeclarationStatement.Type));
Steps.AddCommaSeparatedExpressionSteps(variableDeclarationStatement.Expressions);
}
public override void VisitVariableDeclarationStatement([NotNull] IVariableDeclarationStatement operation)
{
IncrementStatementCount(operation);
base.VisitVariableDeclarationStatement(operation);
}
public VariableBinding(IVariableDeclarationStatement variableDeclaration)
{
MutableBinding = variableDeclaration.Symbol.IsMutableBinding;
Name = variableDeclaration.Symbol.Name;
NameSpan = variableDeclaration.NameSpan;
}
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) =>
{
if (operationContext.Operation is IAssignmentExpression assignment)
{
AssignTo(assignment.Target, localsSourceTypes, fieldsSourceTypes, assignment.Value);
}
else if (operationContext.Operation is IIncrementOrDecrementExpression increment)
{
SyntaxNode syntax = increment.Syntax;
ITypeSymbol type = increment.Type;
Optional <object> constantValue = new Optional <object>(1);
bool isImplicit = increment.IsImplicit;
var value = new LiteralExpression(operationContext.Compilation.GetSemanticModel(syntax.SyntaxTree), syntax, type, constantValue, isImplicit);
AssignTo(increment.Target, localsSourceTypes, fieldsSourceTypes, value);
}
else
{
throw TestExceptionUtilities.UnexpectedValue(operationContext.Operation);
}
},
OperationKind.SimpleAssignmentExpression,
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.FieldInitializer);
// 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);
}
}
});
});
}
