private void AdjustArgument(VBAParser.DictionaryAccessContext dictionaryAccessContext, IModuleRewriter rewriter)
{
var argumentContext = ArgumentContext(dictionaryAccessContext);
rewriter.InsertBefore(argumentContext.Start.TokenIndex, "(\"");
rewriter.InsertAfter(argumentContext.Stop.TokenIndex, "\")");
}
private void InsertAfterFirstEolOfAttributeContext(IModuleRewriter rewriter, Declaration declaration, string codeToAdd)
{
var attributesContext = declaration.AttributesPassContext;
var firstEndOfLineInMember = attributesContext.GetDescendent <VBAParser.EndOfLineContext>();
if (firstEndOfLineInMember == null)
{
var codeToInsert = Environment.NewLine + codeToAdd;
rewriter.InsertAfter(declaration.AttributesPassContext.Stop.TokenIndex, codeToInsert);
}
else
{
var codeToInsert = codeToAdd + Environment.NewLine;
rewriter.InsertAfter(firstEndOfLineInMember.Stop.TokenIndex, codeToInsert);
}
}
public static void MakeImplicitDeclarationTypeExplicit(this IModuleRewriter rewriter, Declaration element)
{
if (!element.Context.TryGetChildContext <VBAParser.AsTypeClauseContext>(out _))
{
rewriter.InsertAfter(element.Context.Stop.TokenIndex, $" {Tokens.As} {element.AsTypeName}");
}
}
private void AddItems(IEnumerable <Declaration> missingMembers, IModuleRewriter rewriter, string interfaceName)
{
var missingMembersText = missingMembers.Aggregate(string.Empty,
(current, member) => current + Environment.NewLine + GetInterfaceMember(member, interfaceName));
rewriter.InsertAfter(rewriter.TokenStream.Size, Environment.NewLine + missingMembersText);
}
public override void Fix(IInspectionResult result)
{
IModuleRewriter rewriter = _state.GetRewriter(result.QualifiedSelection.QualifiedName);
ForNextStmtContext context = result.Context as ForNextStmtContext;
int toExpressionEnd = this.GetToExpressionEnd(context);
rewriter.InsertAfter(toExpressionEnd, " Step 1");
}
private static void MakeImplicitDeclarationTypeExplicit(IReadOnlyCollection <IEncapsulateFieldCandidate> fields, IModuleRewriter rewriter)
{
var fieldsToChange = fields.Where(f => !f.Declaration.Context.TryGetChildContext <VBAParser.AsTypeClauseContext>(out _))
.Select(f => f.Declaration);
foreach (var field in fieldsToChange)
{
rewriter.InsertAfter(field.Context.Stop.TokenIndex, $" {Tokens.As} {field.AsTypeName}");
}
}
private void UpdateCondition(ParserRuleContext condition, IModuleRewriter rewriter)
{
if (condition.GetText().Contains(' '))
{
rewriter.InsertBefore(condition.Start.TokenIndex, "Not (");
rewriter.InsertAfter(condition.Stop.TokenIndex, ")");
}
else
{
rewriter.InsertBefore(condition.Start.TokenIndex, "Not ");
}
}
private void InsertAfterLastModuleAttribute(IModuleRewriter rewriter, QualifiedModuleName module, string codeToAdd)
{
var moduleParseTree = (ParserRuleContext)_parseTreeProvider.GetParseTree(module, CodeKind.AttributesCode);
var lastModuleAttribute = moduleParseTree.GetDescendents <VBAParser.ModuleAttributesContext>()
.Where(moduleAttributes => moduleAttributes.attributeStmt() != null)
.SelectMany(moduleAttributes => moduleAttributes.attributeStmt())
.OrderBy(moduleAttribute => moduleAttribute.stop.TokenIndex)
.LastOrDefault();
if (lastModuleAttribute == null)
{
//This should never happen for a real module.
var codeToInsert = codeToAdd + Environment.NewLine;
rewriter.InsertBefore(0, codeToInsert);
}
else
{
var codeToInsert = Environment.NewLine + codeToAdd;
rewriter.InsertAfter(lastModuleAttribute.stop.TokenIndex, codeToInsert);
}
}
private void InsertLocalVariableDeclarationAndAssignment(IModuleRewriter rewriter, Declaration target, string localIdentifier)
{
var localVariableDeclaration = $"{Tokens.Dim} {localIdentifier} {Tokens.As} {target.AsTypeName}";
var requiresAssignmentUsingSet =
target.References.Any(refItem => VariableRequiresSetAssignmentEvaluator.RequiresSetAssignment(refItem, _declarationFinderProvider));
var localVariableAssignment =
$"{(requiresAssignmentUsingSet ? $"{Tokens.Set} " : string.Empty)}{localIdentifier} = {target.IdentifierName}";
var endOfStmtCtxt = ((ParserRuleContext)target.Context.Parent.Parent).GetChild <VBAParser.EndOfStatementContext>();
var eosContent = endOfStmtCtxt.GetText();
var idxLastNewLine = eosContent.LastIndexOf(Environment.NewLine, StringComparison.InvariantCultureIgnoreCase);
var endOfStmtCtxtComment = eosContent.Substring(0, idxLastNewLine);
var endOfStmtCtxtEndFormat = eosContent.Substring(idxLastNewLine);
var insertCtxt = ((ParserRuleContext)target.Context.Parent.Parent).GetChild <VBAParser.AsTypeClauseContext>()
?? (ParserRuleContext)target.Context.Parent;
rewriter.Remove(endOfStmtCtxt);
rewriter.InsertAfter(insertCtxt.Stop.TokenIndex, $"{endOfStmtCtxtComment}{endOfStmtCtxtEndFormat}{localVariableDeclaration}" + $"{endOfStmtCtxtEndFormat}{localVariableAssignment}{endOfStmtCtxtEndFormat}");
}
private void AddProperty(IModuleRewriter rewriter)
{
UpdateReferences();
SetFieldToPrivate(rewriter);
var members = _model.State.DeclarationFinder
.Members(_model.TargetDeclaration.QualifiedName.QualifiedModuleName)
.OrderBy(declaration => declaration.QualifiedSelection);
var fields = members.Where(d => d.DeclarationType == DeclarationType.Variable && !d.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member)).ToList();
var property = Environment.NewLine + Environment.NewLine + GetPropertyText();
if (members.Any(m => m.DeclarationType.HasFlag(DeclarationType.Member)))
{
property += Environment.NewLine;
}
if (_model.TargetDeclaration.Accessibility != Accessibility.Private)
{
var newField = $"Private {_model.TargetDeclaration.IdentifierName} As {_model.TargetDeclaration.AsTypeName}";
if (fields.Count > 1)
{
newField = Environment.NewLine + newField;
}
property = newField + property;
}
if (_model.TargetDeclaration.Accessibility == Accessibility.Private || fields.Count > 1)
{
rewriter.InsertAfter(fields.Last().Context.Stop.TokenIndex, property);
}
else
{
rewriter.InsertBefore(0, property);
}
}
private void InsertDefaultMember(ParserRuleContext lExpressionContext, QualifiedSelection selection, DeclarationFinder finder, IModuleRewriter rewriter)
{
var defaultMemberAccessCode = DefaultMemberAccessCode(selection, finder);
rewriter.InsertAfter(lExpressionContext.Stop.TokenIndex, defaultMemberAccessCode);
}
