public override void VisitVariableDeclarator([NotNull] IVariableDeclaratorOperation operation)
{
IVariableInitializerOperation initializer = operation.GetVariableInitializer();
if (initializer != null)
{
IdentifiersAssigned.Add(operation.Symbol.Name);
}
base.VisitVariableDeclarator(operation);
}
public override void VisitVariableDeclarator([NotNull] IVariableDeclaratorOperation operation)
{
if (local.Equals(operation.Symbol))
{
IVariableInitializerOperation initializer = operation.GetVariableInitializer();
if (initializer != null)
{
TrySetEvent(initializer.Value);
}
}
base.VisitVariableDeclarator(operation);
}
public override void VisitVariableDeclarator([NotNull] IVariableDeclaratorOperation operation)
{
base.VisitVariableDeclarator(operation);
if (currentLocal.Equals(operation.Symbol) && EndsBeforeMaxLocation(operation))
{
IVariableInitializerOperation initializer = operation.GetVariableInitializer();
if (initializer != null)
{
AnalyzeAssignmentValue(initializer.Value);
}
}
}
public override TAbstractAnalysisValue VisitVariableInitializer(IVariableInitializerOperation operation, object argument)
{
if (operation.Parent is IVariableDeclaratorOperation declarator)
{
return(VisitSymbolInitializer(operation, declarator.Symbol, argument));
}
else if (operation.Parent is IVariableDeclarationOperation declaration)
{
var symbols = declaration.Declarators.Select(d => d.Symbol);
return(VisitSymbolInitializer(operation, symbols, argument));
}
return(base.VisitVariableInitializer(operation, argument));
}
public static IVariableDeclarationOperation CreateVariableDeclaration(ILocalSymbol variable, IVariableInitializerOperation initializer, SemanticModel semanticModel, SyntaxNode syntax)
{
return(CreateVariableDeclaration(ImmutableArray.Create(variable), initializer, semanticModel, syntax));
}
public static VariableDeclaration CreateVariableDeclaration(ImmutableArray <ILocalSymbol> variables, IVariableInitializerOperation initializer, SemanticModel semanticModel, SyntaxNode syntax)
{
return(new VariableDeclaration(
variables,
initializer,
semanticModel,
syntax,
type: null,
constantValue: default(Optional <object>),
isImplicit: false)); // variable declaration is always explicit
}
public override IOperation VisitVariableInitializer(IVariableInitializerOperation operation, object argument)
{
return(new VariableInitializer(Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
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 IAssignmentOperation assignment)
{
AssignTo(assignment.Target, localsSourceTypes, fieldsSourceTypes, assignment.Value);
}
else if (operationContext.Operation is IIncrementOrDecrementOperation 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.SimpleAssignment,
OperationKind.CompoundAssignment,
OperationKind.Increment);
// Track arguments that match out or ref parameters.
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IInvocationOperation invocation = (IInvocationOperation)operationContext.Operation;
foreach (IArgumentOperation argument in invocation.Arguments)
{
if (argument.Parameter.RefKind == RefKind.Out || argument.Parameter.RefKind == RefKind.Ref)
{
AssignTo(argument.Value, localsSourceTypes, fieldsSourceTypes, argument.Parameter.Type);
}
}
},
OperationKind.Invocation);
// Track local variable initializations.
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IVariableInitializerOperation initializer = (IVariableInitializerOperation)operationContext.Operation;
if (initializer.Parent is IVariableDeclarationOperation variableDeclaration)
{
foreach (ILocalSymbol local in variableDeclaration.Variables)
{
AssignTo(local, local.Type, localsSourceTypes, initializer.Value);
}
}
},
OperationKind.VariableInitializer);
// 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) =>
{
IFieldInitializerOperation initializer = (IFieldInitializerOperation)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);
}
}
});
});
}
public override void VisitVariableInitializer(IVariableInitializerOperation operation)
{
Assert.Equal(OperationKind.VariableInitializer, operation.Kind);
Assert.Empty(operation.Locals);
VisitSymbolInitializer(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 IAssignmentOperation assignment)
{
AssignTo(
assignment.Target,
assignedToLocals,
mightBecomeConstLocals
);
}
else if (
operationContext.Operation
is IIncrementOrDecrementOperation increment
)
{
AssignTo(
increment.Target,
assignedToLocals,
mightBecomeConstLocals
);
}
else
{
throw TestExceptionUtilities.UnexpectedValue(
operationContext.Operation
);
}
},
OperationKind.SimpleAssignment,
OperationKind.CompoundAssignment,
OperationKind.Increment
);
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IInvocationOperation invocation =
(IInvocationOperation)operationContext.Operation;
foreach (IArgumentOperation argument in invocation.Arguments)
{
if (
argument.Parameter.RefKind == RefKind.Out ||
argument.Parameter.RefKind == RefKind.Ref
)
{
AssignTo(
argument.Value,
assignedToLocals,
mightBecomeConstLocals
);
}
}
},
OperationKind.Invocation
);
operationBlockContext.RegisterOperationAction(
(operationContext) =>
{
IVariableDeclarationGroupOperation declaration =
(IVariableDeclarationGroupOperation)operationContext.Operation;
foreach (
IVariableDeclaratorOperation variable in declaration.Declarations.SelectMany(
decl => decl.Declarators
)
)
{
ILocalSymbol local = variable.Symbol;
if (!local.IsConst && !assignedToLocals.Contains(local))
{
var localType = local.Type;
if (
(
!localType.IsReferenceType ||
localType.SpecialType
== SpecialType.System_String
) &&
localType.SpecialType != SpecialType.None
)
{
IVariableInitializerOperation initializer =
variable.GetVariableInitializer();
if (
initializer != null &&
initializer.Value.ConstantValue.HasValue
)
{
mightBecomeConstLocals.Add(local);
}
}
}
}
},
OperationKind.VariableDeclarationGroup
);
operationBlockContext.RegisterOperationBlockEndAction(
(operationBlockEndContext) =>
{
foreach (ILocalSymbol couldBeConstLocal in mightBecomeConstLocals)
{
Report(
operationBlockEndContext,
couldBeConstLocal,
LocalCouldBeConstDescriptor
);
}
}
);
}
}
);
}
public virtual void VisitVariableInitializer(IVariableInitializerOperation operation)
{
DefaultVisit(operation);
}
public override void VisitVariableInitializer([NotNull] IVariableInitializerOperation operation)
{
base.VisitVariableInitializer(operation);
}
public override bool VisitVariableInitializer([NotNull] IVariableInitializerOperation operation1,
[CanBeNull] IOperation argument)
{
return(argument is IVariableInitializerOperation operation2 && AreBaseOperationsEqual(operation1, operation2));
}
static void CaptureVariableDeclaratorOperation(DataCollector dataCollector, ITypeSymbol createdType, IVariableInitializerOperation variableInitializerOperation)
{
switch (variableInitializerOperation.Parent)
{
case IVariableDeclaratorOperation declaratorOperation:
dataCollector.CollectVariableDeclaratorOperation(declaratorOperation.Symbol, variableInitializerOperation, createdType);
break;
case IVariableDeclarationOperation declarationOperation when declarationOperation.Declarators.Length == 1:
{
var declaratorOperationAlt = declarationOperation.Declarators[0];
dataCollector.CollectVariableDeclaratorOperation(declaratorOperationAlt.Symbol, variableInitializerOperation, createdType);
break;
}
}
}
