예제 #1
0
        private void UpdateSignature(Declaration targetVariable, IRewriteSession rewriteSession)
        {
            var functionDeclaration = _selectedDeclarationProvider.SelectedMember(targetVariable.QualifiedSelection);
            var paramList           = functionDeclaration.Context.GetChild <VBAParser.ArgListContext>();

            if (functionDeclaration.DeclarationType.HasFlag(DeclarationType.Property))
            {
                UpdateProperties(functionDeclaration, targetVariable, rewriteSession);
            }
            else
            {
                AddParameter(functionDeclaration, targetVariable, paramList, rewriteSession);
            }

            var interfaceImplementation = functionDeclaration.InterfaceMemberImplemented;

            if (interfaceImplementation == null)
            {
                return;
            }

            UpdateSignature(interfaceImplementation, targetVariable, rewriteSession);

            var interfaceImplementations = _declarationFinderProvider.DeclarationFinder.FindInterfaceImplementationMembers(functionDeclaration.InterfaceMemberImplemented)
                                           .Where(member => !ReferenceEquals(member, functionDeclaration));

            foreach (var implementation in interfaceImplementations)
            {
                UpdateSignature(implementation, targetVariable, rewriteSession);
            }
        }
예제 #2
0
        public override void Refactor(ImplicitTypeToExplicitModel model, IRewriteSession rewriteSession)
        {
            if (!(model.Target.Context is VBAParser.VariableSubStmtContext ||
                  model.Target.Context is VBAParser.ConstSubStmtContext ||
                  model.Target.Context is VBAParser.ArgContext))
            {
                throw new ArgumentException($"Invalid target {model.Target.IdentifierName}");
            }

            var identifierNode = model.Target.Context.GetChild <VBAParser.IdentifierContext>()
                                 ?? model.Target.Context.GetChild <VBAParser.UnrestrictedIdentifierContext>() as ParserRuleContext;

            var insertAfterTarget = model.Target.IsArray
                ? model.Target.Context.Stop.TokenIndex
                : identifierNode.Stop.TokenIndex;

            var asTypeName = Tokens.Variant;

            if (!model.ForceVariantAsType)
            {
                var resolver = new ImplicitAsTypeNameResolver(_declarationFinderProvider, _parseTreeValueFactory, model.Target);
                asTypeName = InferAsTypeNameForInspectionResult(model.Target, resolver, new AsTypeNamesResultsHandler());
            }

            var rewriter = rewriteSession.CheckOutModuleRewriter(model.Target.QualifiedModuleName);

            rewriter.InsertAfter(insertAfterTarget, $" {Tokens.As} {asTypeName}");
        }
        public override void Refactor(AnnotateDeclarationModel model, IRewriteSession rewriteSession)
        {
            if (model.AdjustAttribute &&
                rewriteSession.TargetCodeKind != CodeKind.AttributesCode &&
                model.Annotation is IAttributeAnnotation)
            {
                throw new AttributeRewriteSessionRequiredException();
            }

            var targetDeclaration = model.Target;

            if (rewriteSession.TargetCodeKind == CodeKind.AttributesCode &&
                targetDeclaration.AttributesPassContext == null &&
                !targetDeclaration.DeclarationType.HasFlag(DeclarationType.Module))
            {
                throw new AttributeRewriteSessionNotSupportedException();
            }

            var arguments = model.Arguments.Select(ToCode).ToList();

            if (model.AdjustAttribute &&
                model.Annotation is IAttributeAnnotation attributeAnnotation)
            {
                var baseAttribute = attributeAnnotation.Attribute(arguments);
                var attribute     = targetDeclaration.DeclarationType.HasFlag(DeclarationType.Module)
                    ? baseAttribute
                    : Attributes.MemberAttributeName(baseAttribute, targetDeclaration.IdentifierName);
                var attributeValues = attributeAnnotation.AnnotationToAttributeValues(arguments);
                _attributesUpdater.AddOrUpdateAttribute(rewriteSession, targetDeclaration, attribute, attributeValues);
            }

            _annotationUpdater.AddAnnotation(rewriteSession, targetDeclaration, model.Annotation, arguments);
        }
예제 #4
0
        private void InsertNewDeclaration(IRewriteSession rewriteSession)
        {
            var subscripts = _target.Context.GetDescendent <VBAParser.SubscriptsContext>()?.GetText() ?? string.Empty;
            var identifier = _target.IsArray ? $"{_target.IdentifierName}({subscripts})" : _target.IdentifierName;

            var newVariable = _target.AsTypeContext is null
                ? $"{Tokens.Dim} {identifier} {Tokens.As} {Tokens.Variant}{Environment.NewLine}"
                : $"{Tokens.Dim} {identifier} {Tokens.As} {(_target.IsSelfAssigned ? Tokens.New + " " : string.Empty)}{_target.AsTypeNameWithoutArrayDesignator}{Environment.NewLine}";

            var firstReference = _target.References.OrderBy(r => r.Selection.StartLine).First();

            RuleContext expression = firstReference.Context;

            while (!(expression is VBAParser.BlockStmtContext))
            {
                expression = expression.Parent;
            }

            var insertionIndex = (expression as ParserRuleContext).Start.TokenIndex;
            int indentLength;

            using (var pane = _vbe.ActiveCodePane)
            {
                using (var codeModule = pane.CodeModule)
                {
                    var firstReferenceLine = codeModule.GetLines((expression as ParserRuleContext).Start.Line, 1);
                    indentLength = firstReferenceLine.Length - firstReferenceLine.TrimStart().Length;
                }
            }
            var padding = new string(' ', indentLength);

            var rewriter = rewriteSession.CheckOutModuleRewriter(firstReference.QualifiedModuleName);

            rewriter.InsertBefore(insertionIndex, newVariable + padding);
        }
예제 #5
0
 private void Apply(IRewriteSession rewriteSession)
 {
     if (!rewriteSession.TryRewrite())
     {
         _failureNotifier.NotifyQuickFixExecutionFailure(rewriteSession.Status);
     }
 }
예제 #6
0
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);
            var context  = (VBAParser.RemCommentContext)result.Context;

            rewriter.Replace(context.REM(), "'");
        }
예제 #7
0
        private void RenameMember(RenameModel model, IRewriteSession rewriteSession)
        {
            if (model.Target.DeclarationType.HasFlag(DeclarationType.Property))
            {
                var members = _declarationFinderProvider.DeclarationFinder.MatchName(model.Target.IdentifierName)
                              .Where(item => item.ProjectId == model.Target.ProjectId &&
                                     item.ComponentName == model.Target.ComponentName &&
                                     item.DeclarationType.HasFlag(DeclarationType.Property));

                foreach (var member in members)
                {
                    RenameStandardElements(member, model.NewName, rewriteSession);
                }
            }
            else
            {
                RenameStandardElements(model.Target, model.NewName, rewriteSession);
            }

            if (!model.IsInterfaceMemberRename)
            {
                return;
            }

            var implementations = _declarationFinderProvider.DeclarationFinder.FindAllInterfaceImplementingMembers()
                                  .Where(impl => ReferenceEquals(model.Target.ParentDeclaration, impl.InterfaceImplemented) &&
                                         impl.InterfaceMemberImplemented.IdentifierName.Equals(model.Target.IdentifierName));

            RenameDefinedFormatMembers(model, implementations.ToList(), PrependUnderscoreFormat, rewriteSession);
        }
예제 #8
0
        protected override void Refactor(IntroduceParameterModel model, IRewriteSession rewriteSession)
        {
            var target = model.Target;

            UpdateSignature(target, model.EnclosingMember, rewriteSession);
            RemoveTarget(target, rewriteSession);
        }
예제 #9
0
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);
            var context  = result.Context;

            rewriter.Remove(context);
        }
예제 #10
0
        private void UpdateSignature(Declaration target, ParameterDeclaration arg, IRewriteSession rewriteSession)
        {
            var subStmt    = (VBAParser.SubStmtContext)target.Context;
            var argContext = (VBAParser.ArgContext)arg.Context;

            var rewriter = rewriteSession.CheckOutModuleRewriter(target.QualifiedModuleName);

            rewriter.Replace(subStmt.SUB(), Tokens.Function);
            rewriter.Replace(subStmt.END_SUB(), "End Function");

            rewriter.InsertAfter(subStmt.argList().Stop.TokenIndex, $" As {arg.AsTypeName}");

            if (arg.IsByRef)
            {
                rewriter.Replace(argContext.BYREF(), Tokens.ByVal);
            }
            else if (arg.IsImplicitByRef)
            {
                rewriter.InsertBefore(argContext.unrestrictedIdentifier().Start.TokenIndex, Tokens.ByVal);
            }

            var returnStmt = $"    {subStmt.subroutineName().GetText()} = {argContext.unrestrictedIdentifier().GetText()}{Environment.NewLine}";

            rewriter.InsertBefore(subStmt.END_SUB().Symbol.TokenIndex, returnStmt);
        }
        private void AdjustReferences(IEnumerable <IdentifierReference> references, IRewriteSession rewriteSession)
        {
            foreach (var reference in references.Where(item => item.Context != _model.TargetDeclaration.Context))
            {
                VBAParser.ArgumentListContext argumentList = null;
                var callStmt = reference.Context.GetAncestor <VBAParser.CallStmtContext>();
                if (callStmt != null)
                {
                    argumentList = CallStatement.GetArgumentList(callStmt);
                }

                if (argumentList == null)
                {
                    var indexExpression = reference.Context.GetAncestor <VBAParser.IndexExprContext>();
                    if (indexExpression != null)
                    {
                        argumentList = indexExpression.GetChild <VBAParser.ArgumentListContext>();
                    }
                }

                if (argumentList == null)
                {
                    continue;
                }

                var module = reference.QualifiedModuleName;
                RewriteCall(argumentList, module, rewriteSession);
            }
        }
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);
            var context  = (VBAParser.ErrorStmtContext)result.Context;

            rewriter.Replace(context.ERROR(), "Err.Raise");
        }
        public override void Refactor(ModifyUserDefinedTypeModel model, IRewriteSession rewriteSession)
        {
            var newMembers = new List <string>();

            foreach ((Declaration Prototype, string Identifier) in model.MembersToAdd)
            {
                _codeBuilder.TryBuildUDTMemberDeclaration(Prototype, Identifier, out var udtMemberDeclaration);
                newMembers.Add(udtMemberDeclaration);
            }

            var scratchPad = _rewritingManager.CheckOutCodePaneSession().CheckOutModuleRewriter(model.Target.QualifiedModuleName);

            scratchPad.InsertBefore(model.InsertionIndex, $"{Environment.NewLine}{string.Join(Environment.NewLine, newMembers)}");

            foreach (var member in model.MembersToRemove)
            {
                scratchPad.Remove(member);
            }

            var udtDeclarationContext = model.Target.Context as VBAParser.UdtDeclarationContext;
            var newBlock = scratchPad.GetText(udtDeclarationContext.Start.TokenIndex, udtDeclarationContext.Stop.TokenIndex);
            var udtLines = newBlock.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)
                           .Where(ul => !string.IsNullOrEmpty(ul.Trim()));

            var rewriter = rewriteSession.CheckOutModuleRewriter(model.Target.QualifiedModuleName);

            rewriter.Replace(udtDeclarationContext, string.Join(Environment.NewLine, _codeBuilder.Indenter.Indent(udtLines)));
        }
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);

            if (result.Context.Parent.Parent is VBAParser.WithStmtContext withContext)
            {
                var lines = withContext.GetText().Replace("\r", string.Empty).Split('\n');
                // Assume that the End With is at the appropriate indentation level for the block. Note that this could
                // over-indent or under-indent some lines if statement separators are being used, but meh.
                var padding = new string(' ', lines.Last().IndexOf(Tokens.End, StringComparison.Ordinal));

                var replacement = new List <string>
                {
                    $"{Tokens.CommentMarker}TODO - {result.Description}",
                    $"{Tokens.CommentMarker}{padding}{lines.First()}"
                };
                replacement.AddRange(lines.Skip(1)
                                     .Select(line => Tokens.CommentMarker + line));

                rewriter.Replace(withContext, string.Join(Environment.NewLine, replacement));
                return;
            }
            var assignmentContext = result.Context.GetAncestor <VBAParser.LetStmtContext>() ??
                                    (ParserRuleContext)result.Context.GetAncestor <VBAParser.CallStmtContext>();

            rewriter.Remove(assignmentContext);
        }
예제 #15
0
        public void UpdateAnnotation(IRewriteSession rewriteSession, IParseTreeAnnotation annotation, IAnnotation annotationInfo, IReadOnlyList <string> newValues = null)
        {
            var newAnnotationValues = newValues ?? new List <string>();

            if (annotation == null)
            {
                _logger.Warn("Tried to replace an annotation that is null.");
                _logger.Trace($"Tried to replace an annotation that is null with an annotation {annotationInfo.Name} with values {AnnotationValuesText(newAnnotationValues)}.");
                return;
            }

            if (rewriteSession.TargetCodeKind != CodeKind.CodePaneCode && rewriteSession.TargetCodeKind != CodeKind.AttributesCode)
            {
                _logger.Warn($"Tried to update an annotation with a rewriter not suitable for annotationss. (target code kind = {rewriteSession.TargetCodeKind})");
                _logger.Trace($"Tried to update annotation {annotation.Annotation.Name} at {annotation.QualifiedSelection.Selection} in module {annotation.QualifiedSelection.QualifiedName} with annotation {annotationInfo.Name} with values {AnnotationValuesText(newAnnotationValues)} using a rewriter not suitable for annotations.");
                return;
            }

            //If there are no common flags, the annotations cannot apply to the same target.
            if ((annotation.Annotation.Target & annotationInfo.Target) == 0)
            {
                _logger.Warn("Tried to replace an annotation with an annotation without common flags.");
                _logger.Trace($"Tried to replace an annotation {annotation.Annotation.Name} with values {AnnotationValuesText(newValues)} at {annotation.QualifiedSelection.Selection} in module {annotation.QualifiedSelection.QualifiedName} with an annotation {annotationInfo.Name} with values {AnnotationValuesText(newAnnotationValues)}, which does not have any common flags.");
                return;
            }

            var context         = annotation.Context;
            var whitespaceAtEnd = context.whiteSpace()?.GetText() ?? string.Empty;
            var codeReplacement = $"{AnnotationBaseText(annotationInfo.Name, newAnnotationValues)}{whitespaceAtEnd}";

            var rewriter = rewriteSession.CheckOutModuleRewriter(annotation.QualifiedSelection.QualifiedName);

            rewriter.Replace(annotation.Context, codeReplacement);
        }
예제 #16
0
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            if (!(result.Target is ParameterDeclaration parameter))
            {
                return;
            }

            AddByRefIdentifier(rewriteSession, parameter);

            var finder            = _declarationFinderProvider.DeclarationFinder;
            var parentDeclaration = parameter.ParentDeclaration;

            if (parentDeclaration is ModuleBodyElementDeclaration enclosingMember &&
                enclosingMember.IsInterfaceMember)
            {
                var parameterIndex = ParameterIndex(parameter, enclosingMember);
                AddByRefIdentifierToImplementations(enclosingMember, parameterIndex, finder, rewriteSession);
            }

            if (parentDeclaration is EventDeclaration enclosingEvent)
            {
                var parameterIndex = ParameterIndex(parameter, enclosingEvent);
                AddByRefIdentifierToHandlers(enclosingEvent, parameterIndex, finder, rewriteSession);
            }
        }
예제 #17
0
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);

            var duplicateAnnotations = result.Target.Annotations
                                       .Where(annotation => annotation.AnnotationType == result.Properties.AnnotationType)
                                       .OrderBy(annotation => annotation.Context.Start.StartIndex)
                                       .Skip(1)
                                       .ToList();

            var duplicatesPerAnnotationList = duplicateAnnotations
                                              .Select(annotation => (VBAParser.AnnotationListContext)annotation.Context.Parent)
                                              .Distinct()
                                              .ToDictionary(list => list, _ => 0);

            foreach (var annotation in duplicateAnnotations)
            {
                var annotationList = (VBAParser.AnnotationListContext)annotation.Context.Parent;

                RemoveAnnotationMarker(annotationList, annotation, rewriter);

                rewriter.Remove(annotation.Context);

                duplicatesPerAnnotationList[annotationList]++;
            }

            foreach (var pair in duplicatesPerAnnotationList)
            {
                if (OnlyQuoteRemainedFromAnnotationList(pair))
                {
                    rewriter.Remove(pair.Key);
                    rewriter.Remove(((VBAParser.CommentOrAnnotationContext)pair.Key.Parent).NEWLINE());
                }
            }
        }
        public override void Refactor(MoveFolderModel model, IRewriteSession rewriteSession)
        {
            var sourceFolderParent = model.FolderToMove.ParentFolder();
            var changeFolderModel  = new ChangeFolderModel(sourceFolderParent, model.ModulesToMove, model.TargetFolder);

            _changeFolder.Refactor(changeFolderModel, rewriteSession);
        }
예제 #19
0
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            IParseTreeAnnotation oldAnnotation = result.Properties.Annotation;
            string attributeName = result.Properties.AttributeName;
            IReadOnlyList <string> attributeValues = result.Properties.AttributeValues;

            var declaration = result.Target;

            if (declaration.DeclarationType.HasFlag(DeclarationType.Module))
            {
                var componentType = declaration.QualifiedModuleName.ComponentType;
                if (IsDefaultAttribute(componentType, attributeName, attributeValues))
                {
                    _annotationUpdater.RemoveAnnotation(rewriteSession, oldAnnotation);
                }
                else
                {
                    var(newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.ModuleAttributeAnnotation(attributeName, attributeValues);
                    _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotation, newAnnotationValues);
                }
            }
            else
            {
                var attributeBaseName = AttributeBaseName(attributeName, declaration);
                var(newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.MemberAttributeAnnotation(attributeBaseName, attributeValues);
                _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotation, newAnnotationValues);
            }
        }
예제 #20
0
        public void RemoveAttribute(IRewriteSession rewriteSession, Declaration declaration, string attribute, IReadOnlyList <string> values = null)
        {
            if (string.IsNullOrEmpty(attribute))
            {
                return;
            }

            if (declaration == null)
            {
                _logger.Warn("Tried to remove an attribute from a declaration that is null.");
                _logger.Trace($"Tried to remove attribute {attribute} {(values != null ? $"with values {AttributeValuesText(values)} " : string.Empty)}from a declaration that is null.");
                return;
            }

            if (rewriteSession.TargetCodeKind != CodeKind.AttributesCode)
            {
                _logger.Warn($"Tried to remove an attribute with a rewriter not suitable for attributes. (target code kind = {rewriteSession.TargetCodeKind})");
                _logger.Trace($"Tried to remove attribute {attribute} {(values != null ? $"with values {AttributeValuesText(values)} " : string.Empty)}from {declaration.QualifiedModuleName} using a rewriter not suitable for attributes.");
                return;
            }

            var attributeNodes = ApplicableAttributeNodes(declaration, attribute, values);

            if (!attributeNodes.Any())
            {
                return;
            }

            var rewriter = rewriteSession.CheckOutModuleRewriter(declaration.QualifiedModuleName);

            RemoveNodes(rewriter, attributeNodes);
        }
예제 #21
0
        private void UpdateOtherModules(IRewriteSession rewriteSession)
        {
            QualifiedSelection?oldSelection = null;

            using (var pane = _vbe.ActiveCodePane)
            {
                if (!pane.IsWrappingNullReference)
                {
                    oldSelection = pane.GetQualifiedSelection();
                }

                var newTarget = _state.DeclarationFinder.MatchName(_target.IdentifierName).FirstOrDefault(
                    item => item.ComponentName == _target.ComponentName &&
                    item.ParentScope == _target.ParentScope &&
                    item.ProjectId == _target.ProjectId &&
                    Equals(item.Selection, _target.Selection));

                if (newTarget != null)
                {
                    UpdateCallsToOtherModule(newTarget.References.ToList(), rewriteSession);
                }

                if (oldSelection.HasValue)
                {
                    pane.Selection = oldSelection.Value.Selection;
                }
            }
        }
예제 #22
0
        public void AddOrUpdateAttribute(
            IRewriteSession rewriteSession,
            Declaration declaration,
            string attribute,
            IReadOnlyList <string> values)
        {
            var attributeNodes = ApplicableAttributeNodes(declaration, attribute);

            if (!attributeNodes.Any())
            {
                AddAttribute(rewriteSession, declaration, attribute, values);
                return;
            }

            if (attribute.Equals("VB_Ext_Key"))
            {
                var newKey = values.First();
                var matchingExtKeyAttribute = attributeNodes.FirstOrDefault(node => newKey.Equals(node.Values.FirstOrDefault(), StringComparison.InvariantCultureIgnoreCase));

                if (matchingExtKeyAttribute == null)
                {
                    AddAttribute(rewriteSession, declaration, attribute, values);
                    return;
                }

                var oldValues = matchingExtKeyAttribute.Values;
                UpdateAttribute(rewriteSession, declaration, attribute, values, oldValues);
                return;
            }

            UpdateAttribute(rewriteSession, declaration, attribute, values);
        }
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            if (!(result is IWithInspectionResultProperties <(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList <string> AttributeValues)> resultProperties))
            {
                return;
            }

            var declaration = result.Target;

            var(oldParseTreeAnnotation, attributeBaseName, attributeValues) = resultProperties.Properties;

            if (declaration.DeclarationType.HasFlag(DeclarationType.Module))
            {
                var componentType = declaration.QualifiedModuleName.ComponentType;
                if (IsDefaultAttribute(componentType, attributeBaseName, attributeValues))
                {
                    _annotationUpdater.RemoveAnnotation(rewriteSession, oldParseTreeAnnotation);
                }
                else
                {
                    var(newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.ModuleAttributeAnnotation(attributeBaseName, attributeValues);
                    _annotationUpdater.UpdateAnnotation(rewriteSession, oldParseTreeAnnotation, newAnnotation, newAnnotationValues);
                }
            }
            else
            {
                var(newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.MemberAttributeAnnotation(attributeBaseName, attributeValues);
                _annotationUpdater.UpdateAnnotation(rewriteSession, oldParseTreeAnnotation, newAnnotation, newAnnotationValues);
            }
        }
예제 #24
0
        private void AddModuleAnnotation(IRewriteSession rewriteSession, Declaration declaration, IAnnotation annotationInfo, IReadOnlyList <string> annotationValues)
        {
            if (!annotationInfo.Target.HasFlag(AnnotationTarget.Module))
            {
                _logger.Warn("Tried to add an annotation without the module annotation flag to a module.");
                _logger.Trace($"Tried to add the annotation {annotationInfo.Name} with values {AnnotationValuesText(annotationValues)} to the module {declaration.QualifiedModuleName}.");
                return;
            }

            if (rewriteSession.TargetCodeKind != CodeKind.CodePaneCode && rewriteSession.TargetCodeKind != CodeKind.AttributesCode)
            {
                _logger.Warn($"Tried to add an annotation to a module with a rewriter not suitable for annotations. (target code kind = {rewriteSession.TargetCodeKind})");
                _logger.Trace($"Tried to add annotation {annotationInfo.Name} with values {AnnotationValuesText(annotationValues)} to the module {declaration.QualifiedModuleName} using a rewriter not suitable for annotations.");
                return;
            }

            var codeToAdd = AnnotationText(annotationInfo, annotationValues);

            var rewriter = rewriteSession.CheckOutModuleRewriter(declaration.QualifiedModuleName);

            if (rewriteSession.TargetCodeKind == CodeKind.AttributesCode)
            {
                InsertAfterLastModuleAttribute(rewriter, declaration.QualifiedModuleName, codeToAdd);
            }
            else
            {
                var codeToInsert = codeToAdd + Environment.NewLine;
                rewriter.InsertBefore(0, codeToInsert);
            }
        }
        private void UpdateSignature(Declaration targetVariable, IRewriteSession rewriteSession)
        {
            var functionDeclaration = (ModuleBodyElementDeclaration)_declarations.FindTarget(targetVariable.QualifiedSelection, ValidDeclarationTypes);

            var proc      = (dynamic)functionDeclaration.Context;
            var paramList = (VBAParser.ArgListContext)proc.argList();

            if (functionDeclaration.DeclarationType.HasFlag(DeclarationType.Property))
            {
                UpdateProperties(functionDeclaration, targetVariable, rewriteSession);
            }
            else
            {
                AddParameter(functionDeclaration, targetVariable, paramList, rewriteSession);
            }

            var interfaceImplementation = functionDeclaration.InterfaceMemberImplemented;

            if (interfaceImplementation == null)
            {
                return;
            }

            UpdateSignature(interfaceImplementation, targetVariable, rewriteSession);

            var interfaceImplementations = _state.DeclarationFinder.FindInterfaceImplementationMembers(functionDeclaration.InterfaceMemberImplemented)
                                           .Where(member => !ReferenceEquals(member, functionDeclaration));

            foreach (var implementation in interfaceImplementations)
            {
                UpdateSignature(implementation, targetVariable, rewriteSession);
            }
        }
예제 #26
0
        public void AddAnnotation(IRewriteSession rewriteSession, IdentifierReference reference, IAnnotation annotationInfo, IReadOnlyList <string> values = null)
        {
            var annotationValues = values ?? new List <string>();

            if (reference == null)
            {
                _logger.Warn("Tried to add an annotation to an identifier reference that is null.");
                _logger.Trace($"Tried to add annotation {annotationInfo.Name} with values {AnnotationValuesText(annotationValues)} to an identifier reference that is null.");
                return;
            }

            if (!annotationInfo.Target.HasFlag(AnnotationTarget.Identifier))
            {
                _logger.Warn("Tried to add an annotation without the identifier reference annotation flag to an identifier reference.");
                _logger.Trace($"Tried to add annotation {annotationInfo.Name} with values {AnnotationValuesText(annotationValues)} to the identifier reference to {reference.Declaration.QualifiedName} at {reference.Selection} in module {reference.QualifiedModuleName}.");
                return;
            }

            if (rewriteSession.TargetCodeKind != CodeKind.CodePaneCode)
            {
                _logger.Warn($"Tried to add an annotation to an identifier reference with a rewriter not suitable for annotations to references. (target code kind = {rewriteSession.TargetCodeKind})");
                _logger.Trace($"Tried to add annotation {annotationInfo.Name} with values {AnnotationValuesText(annotationValues)} to the the identifier reference {reference.IdentifierName} at {reference.Selection} in module {reference.QualifiedModuleName} using a rewriter not suitable for annotations.");
                return;
            }

            AddAnnotation(rewriteSession, new QualifiedContext(reference.QualifiedModuleName, reference.Context), annotationInfo, annotationValues);
        }
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            var rewriter = rewriteSession.CheckOutModuleRewriter(result.Target.QualifiedModuleName);

            const string asTypeClause = " As Variant";

            switch (result.Target.DeclarationType)
            {
            case DeclarationType.Variable:
                var variableContext = (VBAParser.VariableSubStmtContext)result.Target.Context;
                rewriter.InsertAfter(variableContext.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.LibraryFunction:
                var declareContext = (VBAParser.DeclareStmtContext)result.Target.Context;
                rewriter.InsertAfter(declareContext.argList().Stop.TokenIndex, asTypeClause);
                break;

            case DeclarationType.PropertyGet:
                var propertyContext = (VBAParser.PropertyGetStmtContext)result.Target.Context;
                rewriter.InsertAfter(propertyContext.argList().Stop.TokenIndex, asTypeClause);
                break;
            }
        }
예제 #28
0
        public void RemoveAnnotation(IRewriteSession rewriteSession, IParseTreeAnnotation annotation)
        {
            if (annotation == null)
            {
                _logger.Warn("Tried to remove an annotation that is null.");
                return;
            }

            if (rewriteSession.TargetCodeKind != CodeKind.CodePaneCode)
            {
                _logger.Warn($"Tried to remove an annotation with a rewriter not suitable for annotationss. (target code kind = {rewriteSession.TargetCodeKind})");
                _logger.Trace($"Tried to remove annotation {annotation.Annotation.Name} at {annotation.QualifiedSelection.Selection} in module {annotation.QualifiedSelection.QualifiedName} using a rewriter not suitable for annotations.");
                return;
            }

            var annotationContext = annotation.Context;
            var annotationList    = (VBAParser.AnnotationListContext)annotationContext.Parent;

            var rewriter = rewriteSession.CheckOutModuleRewriter(annotation.QualifiedSelection.QualifiedName);

            var annotations = annotationList.annotation();

            if (annotations.Length == 1)
            {
                RemoveSingleAnnotation(rewriter, annotationContext, annotationList);
            }

            RemoveAnnotationMarker(rewriter, annotationContext);
            rewriter.Remove(annotationContext);
        }
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            var context = result.Context is VBAParser.ConstStmtContext
                ? result.Context
                : (ParserRuleContext)result.Context.Parent;

            string declarationsText;

            switch (context)
            {
            case VBAParser.ConstStmtContext consts:
                declarationsText = GetDeclarationsText(consts);
                break;

            case VBAParser.VariableStmtContext variables:
                declarationsText = GetDeclarationsText(variables);
                break;

            default:
                throw new NotSupportedException();
            }

            var rewriter = rewriteSession.CheckOutModuleRewriter(result.QualifiedSelection.QualifiedName);

            rewriter.Replace(context, declarationsText);
        }
        public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
        {
            if (!(result is IWithInspectionResultProperties <(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList <string> AttributeValues)> resultProperties))
            {
                return;
            }

            var declaration = result.Target;

            var(parseTreeAnnotation, attributeBaseName, attributeValues) = resultProperties.Properties;

            var attributeName = declaration.DeclarationType.HasFlag(DeclarationType.Module)
                ? attributeBaseName
                : Attributes.MemberAttributeName(attributeBaseName, declaration.IdentifierName);

            if (!(parseTreeAnnotation.Annotation is IAttributeAnnotation attributeAnnotation))
            {
                var message = $"Tried to adjust values of attribute {attributeName} to values of non-attribute annotation {parseTreeAnnotation.Annotation.Name} in component {declaration.QualifiedModuleName}.";
                Logger.Warn(message);
                Debug.Fail(message);
                return;
            }

            var attributeValuesFromAnnotation = attributeAnnotation.AttributeValues(parseTreeAnnotation);

            _attributesUpdater.UpdateAttribute(rewriteSession, declaration, attributeName, attributeValuesFromAnnotation, oldValues: attributeValues);
        }