public override void ExitIfStmt(VBAParser.IfStmtContext context)
{
if (context.elseIfBlock() != null && context.elseIfBlock().Any())
{
return;
}
if (context.elseBlock() == null)
{
return;
}
if (!IsSingleBooleanAssignment(context.block()) ||
!IsSingleBooleanAssignment(context.elseBlock().block()))
{
return;
}
// make sure the assignments are the opposite
if (!(ParserRuleContextHelper.GetDescendent <VBAParser.BooleanLiteralIdentifierContext>(context.block()).GetText() == Tokens.True ^
ParserRuleContextHelper.GetDescendent <VBAParser.BooleanLiteralIdentifierContext>(context.elseBlock().block()).GetText() == Tokens.True))
{
return;
}
if (ParserRuleContextHelper.GetDescendent <VBAParser.LetStmtContext>(context.block()).lExpression().GetText().ToLowerInvariant() !=
ParserRuleContextHelper.GetDescendent <VBAParser.LetStmtContext>(context.elseBlock().block()).lExpression().GetText().ToLowerInvariant())
{
return;
}
_contexts.Add(new QualifiedContext <ParserRuleContext>(CurrentModuleName, context));
}
private void ConvertPropertyGet(IInspectionResult result, VBAParser.PropertyGetStmtContext propertyGetContext)
{
var rewriter = _state.GetRewriter(result.Target);
var asTypeContext = ParserRuleContextHelper.GetChild <VBAParser.AsTypeClauseContext>(propertyGetContext);
if (asTypeContext != null)
{
rewriter.Remove(asTypeContext);
rewriter.Remove(propertyGetContext.children.ElementAt(propertyGetContext.children.IndexOf(asTypeContext) - 1) as ParserRuleContext);
}
if (result.Target.TypeHint != null)
{
rewriter.Remove(ParserRuleContextHelper.GetDescendent <VBAParser.TypeHintContext>(propertyGetContext));
}
rewriter.Replace(propertyGetContext.PROPERTY_GET(), Tokens.Sub);
rewriter.Replace(propertyGetContext.END_PROPERTY(), "End Sub");
foreach (var returnStatement in GetReturnStatements(result.Target))
{
rewriter.Remove(returnStatement);
}
}
private bool IsSingleBooleanAssignment(VBAParser.BlockContext block)
{
if (block.ChildCount != 2)
{
return(false);
}
var mainBlockStmtContext =
ParserRuleContextHelper.GetDescendent <VBAParser.MainBlockStmtContext>(block);
return(mainBlockStmtContext.children.FirstOrDefault() is VBAParser.LetStmtContext letStmt &&
letStmt.expression() is VBAParser.LiteralExprContext literal &&
ParserRuleContextHelper.GetDescendent <VBAParser.BooleanLiteralIdentifierContext>(literal) != null);
}
public override void Fix(IInspectionResult result)
{
if (!string.IsNullOrWhiteSpace(result.Target.TypeHint))
{
var rewriter = _state.GetRewriter(result.Target);
var typeHintContext = ParserRuleContextHelper.GetDescendent <VBAParser.TypeHintContext>(result.Context);
rewriter.Remove(typeHintContext);
var asTypeClause = ' ' + Tokens.As + ' ' + SymbolList.TypeHintToTypeName[result.Target.TypeHint];
switch (result.Target.DeclarationType)
{
case DeclarationType.Variable:
var variableContext = (VBAParser.VariableSubStmtContext)result.Target.Context;
rewriter.InsertAfter(variableContext.identifier().Stop.TokenIndex, asTypeClause);
break;
case DeclarationType.Constant:
var constantContext = (VBAParser.ConstSubStmtContext)result.Target.Context;
rewriter.InsertAfter(constantContext.identifier().Stop.TokenIndex, asTypeClause);
break;
case DeclarationType.Parameter:
var parameterContext = (VBAParser.ArgContext)result.Target.Context;
rewriter.InsertAfter(parameterContext.unrestrictedIdentifier().Stop.TokenIndex, asTypeClause);
break;
case DeclarationType.Function:
var functionContext = (VBAParser.FunctionStmtContext)result.Target.Context;
rewriter.InsertAfter(functionContext.argList().Stop.TokenIndex, asTypeClause);
break;
case DeclarationType.PropertyGet:
var propertyContext = (VBAParser.PropertyGetStmtContext)result.Target.Context;
rewriter.InsertAfter(propertyContext.argList().Stop.TokenIndex, asTypeClause);
break;
}
}
foreach (var reference in result.Target.References)
{
var rewriter = _state.GetRewriter(reference.QualifiedModuleName);
var context = ParserRuleContextHelper.GetDescendent <VBAParser.TypeHintContext>(reference.Context);
if (context != null)
{
rewriter.Remove(context);
}
}
}
public override void Fix(IInspectionResult result)
{
var ifContext = (VBAParser.IfStmtContext)result.Context;
var letStmt = ParserRuleContextHelper.GetDescendent <VBAParser.LetStmtContext>(ifContext.block());
var conditional = ifContext.booleanExpression().GetText();
if (letStmt.expression().GetText() == Tokens.False)
{
conditional = $"Not ({conditional})";
}
var rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName);
rewriter.Replace(result.Context, $"{letStmt.lExpression().GetText()} = {conditional}");
}
private static void ReplaceTypeHint(RuleContext context, IModuleRewriter rewriter)
{
var typeHintContext = ParserRuleContextHelper.GetDescendent <VBAParser.TypeHintContext>(context);
rewriter.Replace(typeHintContext, "&");
}
public override void Fix(IInspectionResult result)
{
var rewriter = _state.GetRewriter(result.Target);
rewriter.Replace(ParserRuleContextHelper.GetDescendent <VBAParser.VisibilityContext>(result.Context.Parent.Parent), Tokens.Public);
}
protected override IEnumerable <IInspectionResult> DoGetInspectionResults()
{
return(Listener.Contexts
.Where(result => !IsIgnoringInspectionResultFor(result.ModuleName, result.Context.Start.Line))
.Select(result => new QualifiedContextInspectionResult(this,
string.Format(InspectionsUI.BooleanAssignedInIfElseInspectionResultFormat,
ParserRuleContextHelper.GetDescendent <VBAParser.LetStmtContext>(((VBAParser.IfStmtContext)result.Context).block()).lExpression().GetText().Trim()),
result)));
}