public static AnalysisEntity Create(IInstanceReferenceOperation instanceReferenceOperation, PointsToAbstractValue instanceLocation)
{
Debug.Assert(instanceReferenceOperation != null);
Debug.Assert(instanceLocation != null);
return(new AnalysisEntity(instanceReferenceOperation, instanceLocation));
}
private bool ValidateExpression(IExpressionStatementOperation expressionStatement)
{
if (expressionStatement.Operation?.Kind != OperationKind.Invocation)
{
return(false);
}
var invocation = (IInvocationOperation)expressionStatement.Operation;
// Valid calls are either to Dispose(false), or to the Finalize method of the base type
if (!_callDispose)
{
bool result = IsDisposeBoolCall(invocation, _type, expectedValue: false);
if (result)
{
_callDispose = true;
}
return(result);
}
else if (_type.BaseType != null && invocation.Instance != null && invocation.Instance.Kind == OperationKind.InstanceReference)
{
IMethodSymbol methodSymbol = invocation.TargetMethod;
IInstanceReferenceOperation receiver = (IInstanceReferenceOperation)invocation.Instance;
return(methodSymbol.IsFinalizer() && Equals(receiver.Type.OriginalDefinition, _type.BaseType.OriginalDefinition));
}
return(false);
}
public override PointsToAbstractValue VisitInstanceReference(IInstanceReferenceOperation operation, object argument)
{
var _ = base.VisitInstanceReference(operation, argument);
IOperation currentInstanceOperation = operation.GetInstance();
return(currentInstanceOperation != null?
GetCachedAbstractValue(currentInstanceOperation) :
ThisOrMePointsToAbstractValue);
}
private AnalysisEntity(IInstanceReferenceOperation instanceReferenceOperation, PointsToAbstractValue location)
{
Debug.Assert(instanceReferenceOperation != null);
Debug.Assert(location != null);
InstanceReferenceOperationSyntaxOpt = instanceReferenceOperation.Syntax;
InstanceLocation = location;
Type = instanceReferenceOperation.Type;
Indices = ImmutableArray <AbstractIndex> .Empty;
}
/// <summary>
/// Gets the operation for the object being created that is being referenced by <paramref name="operation"/>.
/// If the operation is referencing an implicit or an explicit this/base/Me/MyBase/MyClass instance, then we return "null".
/// </summary>
/// <param name="operation"></param>
/// <param name="isInsideObjectInitializer">Flag to indicate if the operation is a descendant of an <see cref="IObjectOrCollectionInitializerOperation"/> or an <see cref="IAnonymousObjectCreationOperation"/>.</param>
/// <remarks>
/// PERF: Note that the parameter <paramref name="isInsideObjectInitializer"/> is to improve performance by avoiding walking the entire IOperation parent for non-initializer cases.
/// </remarks>
public static IOperation GetInstance(this IInstanceReferenceOperation operation, bool isInsideObjectInitializer)
{
Debug.Assert(isInsideObjectInitializer ==
(operation.GetAncestor <IObjectOrCollectionInitializerOperation>(OperationKind.ObjectOrCollectionInitializer) != null ||
operation.GetAncestor <IAnonymousObjectCreationOperation>(OperationKind.AnonymousObjectCreation) != null));
if (isInsideObjectInitializer)
{
for (IOperation current = operation; current != null && current.Kind != OperationKind.Block; current = current.Parent)
{
switch (current.Kind)
{
// VB object initializer allows accessing the members of the object being created with "." operator.
// The syntax of such an IInstanceReferenceOperation points to the object being created.
// Check for such an IObjectCreationOperation or IAnonymousObjectCreationOperation with matching syntax.
// For example, instance reference for members ".Field1" and ".Field2" in "New C() With { .Field1 = 0, .Field2 = .Field1 }".
case OperationKind.ObjectCreation:
case OperationKind.AnonymousObjectCreation:
if (current.Syntax == operation.Syntax)
{
return(current);
}
break;
// IInstanceReferenceOperation on left of an IMemberInitializerOperation refers to the ancestor IObjectCreationOperation/IAnonymousObjectCreationOperation/IMemberInitializerOperation.
// For example, implicit instance reference for member initializer "AnotherType" in "new C() { AnotherType = { IntField = 0 } };", where "AnotherType" is a member of named type kind.
case OperationKind.MemberInitializer:
var parentMemberInitializer = (IMemberInitializerOperation)current;
if (parentMemberInitializer.InitializedMember.DescendantsAndSelf().Contains(operation))
{
return(parentMemberInitializer.GetCreation());
}
break;
// IInstanceReferenceOperation on left of an ISimpleAssignmentOperation with an IObjectOrCollectionInitializerOperation parent refers to the parenting IObjectCreationOperation/IAnonymousObjectCreationOperation/IMemberInitializerOperation.
// For example, implicit instance reference for "IntField" in "new C() { IntField = 0 };".
case OperationKind.SimpleAssignment:
var parentSimpleAssignmentInitialier = (ISimpleAssignmentOperation)current;
if (parentSimpleAssignmentInitialier.Parent is IObjectOrCollectionInitializerOperation &&
parentSimpleAssignmentInitialier.Target.DescendantsAndSelf().Contains(operation))
{
return(parentSimpleAssignmentInitialier.Parent.Parent);
}
break;
}
}
}
// For all other cases, IInstanceReferenceOperation refers to the implicit or explicit this/base/Me/MyBase/MyClass reference.
// We return null for such cases.
return(null);
}
public override PointsToAbstractValue VisitInstanceReference(IInstanceReferenceOperation operation, object argument)
{
var _ = base.VisitInstanceReference(operation, argument);
IOperation currentInstanceOperation = operation.GetInstance(IsInsideObjectInitializer);
var value = currentInstanceOperation != null?
GetCachedAbstractValue(currentInstanceOperation) :
ThisOrMePointsToAbstractValue;
Debug.Assert(value.NullState == NullAbstractValue.NotNull);
return(value);
}
/// <summary>
/// Gets the operation for the object being created that is being referenced by <paramref name="operation"/>.
/// If the operation is referencing an implicit or an explicit this/base/Me/MyBase/MyClass instance, then we return "null".
/// </summary>
public static IOperation GetInstance(this IInstanceReferenceOperation operation)
{
// VB object initializer allows accessing the members of the object being created with "." operator.
// The syntax of such an IInstanceReferenceOperation points to the object being created.
// Check for such an IObjectCreationOperation or IAnonymousObjectCreationOperation with matching syntax.
// For example, instance reference for members ".Field1" and ".Field2" in "New C() With { .Field1 = 0, .Field2 = .Field1 }".
Func <IObjectCreationOperation, bool> isObjectCreation = creation => creation.Syntax == operation.Syntax;
var objectCreation = operation.GetAncestor(OperationKind.ObjectCreation, isObjectCreation);
if (objectCreation != null)
{
return(objectCreation);
}
Func <IAnonymousObjectCreationOperation, bool> isAnonymousObjectCreation = creation => creation.Syntax == operation.Syntax;
var anonymousObjectCreation = operation.GetAncestor(OperationKind.AnonymousObjectCreation, isAnonymousObjectCreation);
if (anonymousObjectCreation != null)
{
return(anonymousObjectCreation);
}
// IInstanceReferenceOperation on left of an IMemberInitializerOperation refers to the ancestor IObjectCreationOperation/IAnonymousObjectCreationOperation/IMemberInitializerOperation.
// For example, implicit instance reference for member initializer "AnotherType" in "new C() { AnotherType = { IntField = 0 } };", where "AnotherType" is a member of named type kind.
IMemberInitializerOperation parentMemberInitializer = operation.GetAncestor <IMemberInitializerOperation>(OperationKind.MemberInitializer);
if (parentMemberInitializer != null &&
parentMemberInitializer.InitializedMember.DescendantsAndSelf().Contains(operation))
{
return(parentMemberInitializer.GetCreation());
}
// IInstanceReferenceOperation on left of an ISimpleAssignmentOperation with an IObjectOrCollectionInitializerOperation parent refers to the parenting IObjectCreationOperation/IAnonymousObjectCreationOperation/IMemberInitializerOperation.
// For example, implicit instance reference for "IntField" in "new C() { IntField = 0 };".
ISimpleAssignmentOperation parentSimpleAssignmentInitialier = operation.GetAncestor <ISimpleAssignmentOperation>(OperationKind.SimpleAssignment);
if (parentSimpleAssignmentInitialier != null &&
parentSimpleAssignmentInitialier.Parent is IObjectOrCollectionInitializerOperation &&
parentSimpleAssignmentInitialier.Target.DescendantsAndSelf().Contains(operation))
{
return(parentSimpleAssignmentInitialier.Parent.Parent);
}
// For all cases, IInstanceReferenceOperation refers to the implicit or explicit this/base/Me/MyBase/MyClass reference.
// We return null for such cases.
return(null);
}
public override MultiValue VisitInstanceReference(IInstanceReferenceOperation instanceRef, StateValue state)
{
if (instanceRef.ReferenceKind != InstanceReferenceKind.ContainingTypeInstance)
{
return(TopValue);
}
// The instance reference operation represents a 'this' or 'base' reference to the containing type,
// so we get the annotation from the containing method.
// TODO: Check whether the Context.OwningSymbol is the containing type in case we are in a lambda.
if (instanceRef.Type != null && instanceRef.Type.IsTypeInterestingForDataflow())
{
return(new MethodThisParameterValue((IMethodSymbol)Context.OwningSymbol));
}
return(TopValue);
}
public static AnalysisEntity Create(IInstanceReferenceOperation instanceReferenceOperation, PointsToAbstractValue instanceLocation)
{
return(new AnalysisEntity(instanceReferenceOperation, instanceLocation));
}
public override NullAbstractValue VisitInstanceReference(IInstanceReferenceOperation operation, object argument)
{
var _ = base.VisitInstanceReference(operation, argument);
return(NullAbstractValue.NotNull);
}
public override IOperation VisitInstanceReference(IInstanceReferenceOperation operation, object argument)
{
return(new InstanceReferenceExpression(operation.ReferenceKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public virtual void VisitInstanceReference(IInstanceReferenceOperation operation)
{
DefaultVisit(operation);
}
public override void VisitInstanceReference([NotNull] IInstanceReferenceOperation operation)
{
base.VisitInstanceReference(operation);
}
public override bool VisitInstanceReference([NotNull] IInstanceReferenceOperation operation1,
[CanBeNull] IOperation argument)
{
return(argument is IInstanceReferenceOperation operation2 && AreBaseOperationsEqual(operation1, operation2));
}
private AnalysisEntity(IInstanceReferenceOperation instanceReferenceOperation, PointsToAbstractValue location)
: this(symbolOpt : null, indices : ImmutableArray <AbstractIndex> .Empty, instanceReferenceOperationSyntaxOpt : instanceReferenceOperation.Syntax,
location : location, type : instanceReferenceOperation.Type, parentOpt : null, isThisOrMeInstance : false)
{
Debug.Assert(instanceReferenceOperation != null);
}
public override void VisitInstanceReference(IInstanceReferenceOperation operation)
{
Assert.Equal(OperationKind.InstanceReference, operation.Kind);
Assert.Empty(operation.Children);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="operation">IOperationインスタンス</param>
/// <param name="container">イベントコンテナ</param>
public InstanceReference(IInstanceReferenceOperation operation, EventContainer container) : base(container)
{
Expressions.Add(new Expression("this", Expression.GetSymbolTypeName(operation.Type)));
}
