protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
{
return(declaration.IdentifierName.Contains("_") &&
(declaration.Accessibility == Accessibility.Public ||
declaration.Accessibility == Accessibility.Implicit) &&
declaration.ParentDeclaration.DeclarationType.HasFlag(DeclarationType.ClassModule) &&
!finder.FindEventHandlers().Contains(declaration) &&
!(declaration is ModuleBodyElementDeclaration member && member.IsInterfaceImplementation));
}
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder, string[] whitelistedNames)
{
return(!string.IsNullOrEmpty(declaration.IdentifierName) &&
!IgnoreDeclarationTypes.Contains(declaration.DeclarationType) &&
!(declaration.Context is VBAParser.LineNumberLabelContext) &&
(declaration.ParentDeclaration == null ||
!IgnoreDeclarationTypes.Contains(declaration.ParentDeclaration.DeclarationType) &&
!finder.FindEventHandlers().Contains(declaration.ParentDeclaration)) &&
!whitelistedNames.Contains(declaration.IdentifierName) &&
!VBAIdentifierValidator.IsMeaningfulIdentifier(declaration.IdentifierName));
}
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
{
return(!declaration.References
.Any(reference => !reference.ParentScoping.Equals(declaration)) && // ignore recursive/self-referential calls
!finder.FindEventHandlers().Contains(declaration) &&
!IsClassLifeCycleHandler(declaration) &&
!(declaration is ModuleBodyElementDeclaration member &&
(member.IsInterfaceMember ||
member.IsInterfaceImplementation)) &&
!declaration.Annotations
.Any(pta => pta.Annotation is ITestAnnotation) &&
!IsDocumentEventHandler(declaration) &&
!IsEntryPoint(declaration));
}
private static void AddByRefIdentifierToHandlers(
EventDeclaration eventDeclaration,
int parameterIndex,
DeclarationFinder finder,
IRewriteSession rewriteSession)
{
var handlers = finder.FindEventHandlers(eventDeclaration)
.Select(implementation => implementation.Parameters[parameterIndex]);
foreach (var parameter in handlers)
{
AddByRefIdentifier(rewriteSession, parameter);
}
}
private static bool ParameterIsResult(ParameterDeclaration parameter, DeclarationFinder finder)
{
var enclosingMember = parameter.ParentDeclaration;
if (!(enclosingMember is ModuleBodyElementDeclaration member))
{
return(false);
}
return(!member.IsInterfaceImplementation &&
member.DeclarationType != DeclarationType.LibraryFunction &&
member.DeclarationType != DeclarationType.LibraryProcedure &&
!finder.FindEventHandlers().Contains(member));
}
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
{
if (!(declaration is ParameterDeclaration parameter) ||
!parameter.IsImplicitByRef ||
parameter.IsParamArray
//Exclude parameters of Declare statements
|| !(parameter.ParentDeclaration is ModuleBodyElementDeclaration enclosingMethod))
{
return(false);
}
return(!IsPropertyMutatorRHSParameter(enclosingMethod, parameter) &&
!enclosingMethod.IsInterfaceImplementation &&
!finder.FindEventHandlers().Contains(enclosingMethod));
}
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
{
if (!(declaration is ModuleBodyElementDeclaration member) ||
member.IsInterfaceImplementation ||
member.IsInterfaceMember ||
finder.FindEventHandlers().Contains(member) ||
member.Parameters.Count(param => param.IsByRef && !param.IsParamArray) != 1)
{
return(false);
}
var parameter = member.Parameters.First(param => param.IsByRef && !param.IsParamArray);
var parameterReferences = parameter.References.ToList();
return(parameterReferences.Any(reference => IsAssignment(reference, finder)));
}
private static bool AllHandlerParametersCanBeChangedToByVal(ParameterDeclaration parameter, EventDeclaration eventDeclaration, DeclarationFinder finder)
{
if (!TryFindParameterIndex(parameter, eventDeclaration, out var parameterIndex))
{
//This really should never happen.
Debug.Fail($"Could not find index for parameter {parameter.IdentifierName} in event {eventDeclaration.IdentifierName}.");
return(false);
}
if (!eventDeclaration.IsUserDefined)
{
return(false);
}
var handlers = finder.FindEventHandlers(eventDeclaration);
return(handlers.All(handler => ParameterAtIndexCanBeChangedToBePassedByValIfRelatedParameterCan(handler, parameterIndex, finder)));
}
private static bool ThereAreHandlersAndNoneUsesTheParameter(ParameterDeclaration parameter, EventDeclaration eventDeclaration, DeclarationFinder finder)
{
if (!TryFindParameterIndex(parameter, eventDeclaration, out var parameterIndex))
{
//This really should never happen.
Debug.Fail($"Could not find index for parameter {parameter.IdentifierName} in event {eventDeclaration.IdentifierName}.");
return(false);
}
if (!eventDeclaration.IsUserDefined)
{
return(false);
}
var handlers = finder.FindEventHandlers(eventDeclaration).ToList();
//We do not want to report all parameters of not handled events.
return(handlers.Any() &&
handlers.All(handler => ParameterAtIndexIsNotUsed(handler, parameterIndex)));
}
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
{
if (!(declaration is ParameterDeclaration parameter) ||
!parameter.IsImplicitByRef ||
parameter.IsParamArray)
{
return(false);
}
var parentDeclaration = parameter.ParentDeclaration;
if (parentDeclaration is ModuleBodyElementDeclaration enclosingMethod)
{
return(!enclosingMethod.IsInterfaceImplementation &&
!finder.FindEventHandlers().Contains(enclosingMethod));
}
return(parentDeclaration.DeclarationType != DeclarationType.LibraryFunction &&
parentDeclaration.DeclarationType != DeclarationType.LibraryProcedure);
}
protected override (bool isResult, Declaration properties) IsResultDeclarationWithAdditionalProperties(
Declaration userDeclaration,
DeclarationFinder finder,
IDictionary <string, HashSet <string> > referencedProjectIdsByProjectId)
{
// The user has no control over build-in event handlers or their parameters, so we skip them.
//TODO: Find a way to restrict this to event handlers for built-in events. (Revisit after #5379 is closed.)
var eventHandlers = finder.FindEventHandlers();
if (DeclarationIsPartOfEventHandler(userDeclaration, eventHandlers))
{
return(false, null);
}
if (!referencedProjectIdsByProjectId.TryGetValue(userDeclaration.ProjectId, out var referencedProjectIds))
{
referencedProjectIds = new HashSet <string>();
}
var shadowedDeclaration = ShadowedDeclaration(userDeclaration, referencedProjectIds, finder);
return(shadowedDeclaration != null, shadowedDeclaration);
}
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
{
if (declaration.References.Any() ||
!(declaration is ParameterDeclaration parameter))
{
return(false);
}
var enclosingMember = parameter.ParentDeclaration;
if (IsLibraryMethod(enclosingMember))
{
return(false);
}
if (enclosingMember is EventDeclaration eventDeclaration)
{
return(ThereAreHandlersAndNoneUsesTheParameter(parameter, eventDeclaration, finder));
}
if (enclosingMember is ModuleBodyElementDeclaration member)
{
if (member.IsInterfaceMember)
{
return(ThereAreImplementationsAndNoneUsesTheParameter(parameter, member, finder));
}
if (member.IsInterfaceImplementation ||
finder.FindEventHandlers().Contains(member))
{
return(false);
}
}
return(true);
}
private static bool IsEventHandler(Declaration declaration, DeclarationFinder finder)
{
return(finder.FindEventHandlers().Contains(declaration) ||
finder.FindFormEventHandlers().Contains(declaration));
}
