Пример #1
0
        public void Execute(ISolution solution, ITextControl textControl)
        {
            if (!_literalExpression.IsValid())
            {
                return;
            }

            var containingFile = _literalExpression.GetContainingFile();
            var psiModule      = _literalExpression.GetPsiModule();
            var elementFactory = CSharpElementFactory.GetInstance(_literalExpression);

            IExpression newExpression = null;

            _literalExpression.GetPsiServices().Transactions.Execute(GetType().Name, () =>
            {
                using (solution.GetComponent <IShellLocks>().UsingWriteLock())
                    newExpression = ModificationUtil.ReplaceChild(
                        _literalExpression.Task, elementFactory.CreateExpression("$0.ConfigureAwait($1)", _literalExpression.Task,
                                                                                 elementFactory.CreateExpressionByConstantValue(CSharpConstantValueFactory.CreateBoolValue(_value, psiModule))));
            });

            if (newExpression != null)
            {
                IRangeMarker marker = newExpression.GetDocumentRange().CreateRangeMarker(solution.GetComponent <DocumentManager>());
                containingFile.OptimizeImportsAndRefs(marker, false, true, NullProgressIndicator.Create());
            }
        }
Пример #2
0
        private void ProcessBehaviorContainer(IDeclaredElement element)
        {
            var solution = element.GetSolution();

            var finder       = solution.GetPsiServices().Finder;
            var searchDomain = _searchDomainFactory.CreateSearchDomain(solution, false);
            var consumer     = new SearchResultsConsumer();
            var progress     = NullProgressIndicator.Create();

            finder.Find(new[] { element }, searchDomain, consumer, SearchPattern.FIND_USAGES, progress);

            var contexts = consumer.GetOccurrences()
                           .OfType <ReferenceOccurrence>()
                           .Select(x => x.GetTypeElement().GetValidDeclaredElement())
                           .OfType <IClass>()
                           .Where(x => x.IsContext());

            foreach (var context in contexts)
            {
                var type        = context.AsTypeInfo();
                var declaration = context.GetDeclarations().FirstOrDefault();

                if (declaration != null)
                {
                    ProcessContext(type, declaration, false);

                    foreach (var field in type.GetFields())
                    {
                        ProcessField(declaration.GetProject(), field);
                    }
                }
            }
        }
Пример #3
0
        public IEnumerable <ITypeElement> GetLinkedTypes(IReadOnlyList <ITypeElement> allSourceTypes, IPsiServices services)
        {
            foreach (var sourceType in allSourceTypes)
            {
                foreach (var linkedType in GetLinkedTypes(sourceType))
                {
                    yield return(linkedType);

                    if (!ReferenceEquals(sourceType, allSourceTypes[index: 0]))
                    {
                        continue;
                    }

                    var derivedLinkedTypes = new List <ITypeElement>();
                    services.Finder.FindInheritors(linkedType, new FindResultConsumer(x =>
                    {
                        var typeElement = (x as FindResultDeclaredElement)?.DeclaredElement as ITypeElement;
                        if (typeElement != null)
                        {
                            derivedLinkedTypes.Add(typeElement);
                        }

                        return(FindExecution.Continue);
                    }), NullProgressIndicator.Create());

                    foreach (var derivedLinkedType in derivedLinkedTypes)
                    {
                        yield return(derivedLinkedType);
                    }
                }
            }
        }
Пример #4
0
        public static IReadOnlyCollection <ITypeElement> GetLinkedTypes(ITypeElement source)
        {
            var sources = new[] { source }
            .Concat(source.GetAllSuperTypes()
                    .Select(x => x.GetTypeElement())
                    .WhereNotNull()
                    .Where(x => !x.IsObjectClass()));

            var linkedTypes = sources.SelectMany(GetLinkedTypesInternal).ToList();

            // TODO move to Internal method
            var services = source.GetPsiServices();

            linkedTypes.ForEach(x => services.Finder.FindInheritors(x, new FindResultConsumer(y =>
            {
                if ((y as FindResultDeclaredElement)?.DeclaredElement is ITypeElement typeElement)
                {
                    linkedTypes.Add(typeElement);
                }

                return(FindExecution.Continue);
            }), NullProgressIndicator.Create()));

            return(linkedTypes);
        }
Пример #5
0
        public void TestNullProgressIndicatorUpdate()
        {
            NullProgressIndicator np = new NullProgressIndicator();

            np.UpdateProgress(50, 100, "description");
            Assert.AreEqual("", standardOut.ToString());
        }
        public void Execute(ISolution solution, ITextControl textControl)
        {
            Shell.Instance.GetComponent <UITaskExecutor>().SingleThreaded.ExecuteTask("Cleanup file", TaskCancelable.No, progress =>
            {
                progress.TaskName = _profile.Name;
                progress.Start(1);

                using (Shell.Instance.GetComponent <ICommandProcessor>().UsingBatchTextChange("Code Cleanup"))
                {
                    using (var cookie = solution.GetComponent <SolutionDocumentTransactionManager>().CreateTransactionCookie(DefaultAction.Rollback, "Code cleanup"))
                    {
                        var progressIndicator = NullProgressIndicator.Create();

                        CodeCleanup instance = CodeCleanup.GetInstance(solution);

                        int caret = -1;
                        instance.Run(this._dataProvider.SourceFile, DocumentRange.InvalidRange, ref caret, _profile, NullProgressIndicator.Create());

                        cookie.Commit(progressIndicator);
                    }
                }

                progress.Stop();
            });
        }
        public static void OrginizeUsingsAndFormatFile(ISolution solution, IDocument document)
        {
            IPsiSourceFile sourceFile  = document.GetPsiSourceFile(solution);
            IPsiServices   psiServices = solution.GetPsiServices();

            psiServices.Files.CommitAllDocuments();

            PsiTransactionCookie.ExecuteConditionally(
                psiServices,
                () =>
            {
                if (sourceFile?.GetPsiFile(CSharpLanguage.Instance, new DocumentRange(document, 0)) is ICSharpFile psiFile)
                {
                    SortImports(psiFile);

                    psiFile.OptimizeImportsAndRefs(
                        new RangeMarker(document.ToPointer(), new TextRange(0, document.DocumentRange.Length)),
                        true /* optimizeUsings */,
                        true /* shortenReferences */,
                        NullProgressIndicator.Create()
                        );

                    psiFile.FormatNode();
                }

                return(true);
            },
                "Format T4 Generated File"
                );
        }
        public void Execute(IDataContext context, DelegateExecute nextExecute)
        {
            var solution = context.GetData(ProjectModelDataConstants.SOLUTION);

            if (solution == null)
            {
                return;
            }

            var workflow = new ConvertWebFormsToRazorRefactoringWorkflow(
                solution,
                nameof(ConvertWebFormsToRazorAction),
                context.GetComponent <RazorConverterSettingsStore>(),
                Shell.Instance.GetComponent <IMainWindowPopupWindowContext>());

            if (!workflow.IsAvailable(context) || !workflow.Initialize(context))
            {
                return;
            }

            using (var pi = NullProgressIndicator.Create())
            {
                workflow.PreExecute(pi);
                workflow.Execute(pi);
                workflow.PostExecute(pi);
            }
        }
Пример #9
0
        public void TestNullProgressIndicatorComplete()
        {
            NullProgressIndicator np = new NullProgressIndicator();

            np.Complete();
            Assert.AreEqual("", standardOut.ToString());
        }
Пример #10
0
        static void Analyze([NotNull] ILocalFunctionDeclaration localFunctionDeclaration, [NotNull] IHighlightingConsumer consumer)
        {
            if (!localFunctionDeclaration.IsAsync || !localFunctionDeclaration.IsVoidMethodDeclaration())
            {
                return; // not an "async void" local function
            }

            var psiServices = localFunctionDeclaration.GetPsiServices();

            Debug.Assert(SearchDomainFactory.Instance != null);

            var solutionSearchDomain = SearchDomainFactory.Instance.CreateSearchDomain(psiServices.Solution, false);
            var references           = psiServices.Finder.FindReferences(
                localFunctionDeclaration.DeclaredElement,
                solutionSearchDomain,
                NullProgressIndicator.Create());
            var count = references.Count(reference => !reference.AssertNotNull().IsEventTarget());

            if (count > 0)
            {
                consumer.AddHighlighting(
                    new AvoidAsyncVoidHighlighting(
                        string.Format(
                            "'async void' local function used {0} time{1} not as a direct event handler.",
                            count.ToString(),
                            count == 1 ? "" : "s"),
                        localFunctionDeclaration));
            }
        }
Пример #11
0
            private Action <ITextControl> ChangeParameters(ISolution solution)
            {
                var model = ClrChangeSignatureModel.CreateModel(myMethodDeclaration.DeclaredElement).NotNull();

                for (var i = 0; i < myExpectedMethodSignature.Parameters.Length; i++)
                {
                    var requiredParameter = myExpectedMethodSignature.Parameters[i];

                    var modelParameter = FindBestMatch(requiredParameter, model, i);
                    if (modelParameter != null)
                    {
                        // If the current index is correct, do nothing. If not, use the original index to find the item to move
                        if (modelParameter.ParameterIndex != i)
                        {
                            model.MoveTo(modelParameter.OriginalParameterIndex, i);
                        }
                    }
                    else
                    {
                        model.Add(i);
                        modelParameter = model.ChangeSignatureParameters[i];
                    }

                    modelParameter.ParameterName = requiredParameter.Name;
                    modelParameter.ParameterKind = ParameterKind.VALUE;
                    modelParameter.ParameterType = requiredParameter.Type;

                    // Reset everything else
                    modelParameter.IsOptional = false;
                    modelParameter.IsParams   = false;
                    modelParameter.IsThis     = false;
                    modelParameter.IsVarArg   = false;
                }

                for (var i = model.ChangeSignatureParameters.Length - 1;
                     i >= myExpectedMethodSignature.Parameters.Length;
                     i--)
                {
                    model.RemoveAt(i);
                }

                var refactoring = new ChangeSignatureRefactoring(model);

                refactoring.Execute(NullProgressIndicator.Create());

                // Ideally, we would now call InplaceRefactoringsManager.Reset to make sure we didn't have
                // an inplace refactoring highlight. But InplaceRefactoringsManager is internal, so we can't.
                // We don't want a highlight telling us to "apply signature change refactoring" because we
                // just have. The only way to remove it is to fire the Escape action
                return(tc =>
                {
                    var highlightingManager = solution.GetComponent <InplaceRefactoringsHighlightingManager>();
                    if (highlightingManager.GetHighlightersForTests(tc).Any())
                    {
                        var actionManager = solution.GetComponent <IActionManager>();
                        var escapeActionHandler = actionManager.Defs.GetActionDef <EscapeActionHandler>();
                        escapeActionHandler.EvaluateAndExecute(actionManager);
                    }
                });
            }
        private static bool TryGenerateFile(
            ISolution solution,
            IProjectFile sourceFile,
            string filePath,
            string generatedText,
            out IProjectFile generatedFile)
        {
            using (var progressIndicator = NullProgressIndicator.Create())
            {
                IProjectModelTransactionCookie transaction =
                    solution.CreateTransactionCookie(DefaultAction.Rollback, "T4 Generating file", progressIndicator);
                using (transaction)
                {
                    if (!TryCreateFile(filePath, solution, sourceFile, transaction, out generatedFile))
                    {
                        return(false);
                    }

                    IDocument generatedDocument = generatedFile.GetDocument();
                    generatedDocument.ReplaceText(generatedDocument.DocumentRange, generatedText);

                    ExecutionHelpers.OrginizeUsingsAndFormatFile(solution, generatedDocument);

                    transaction.Commit(progressIndicator);
                }
            }

            return(true);
        }
        private static bool TryGenerateFiles(
            ISolution solution,
            List <FileGeneratorOutput> fileGeneratorOutputs,
            List <InPlaceGeneratorOutput> inPlaceGeneratorOutputs)
        {
            if (!TryProcessFilePaths(solution, fileGeneratorOutputs, out List <FileGeneratorOutput> notFoundProjectFolderOutputs))
            {
                return(false);
            }

            using (var progressIndicator = NullProgressIndicator.Create())
            {
                IProjectModelTransactionCookie transaction =
                    solution.CreateTransactionCookie(DefaultAction.Rollback, "T4 Generating files", progressIndicator);
                using (transaction)
                {
                    if (!TryCreateProjectFolders(notFoundProjectFolderOutputs, transaction))
                    {
                        return(false);
                    }

                    if (!TryCreateFiles(fileGeneratorOutputs, transaction))
                    {
                        return(false);
                    }

                    MakeDocumentChanges(solution, fileGeneratorOutputs, inPlaceGeneratorOutputs);

                    transaction.Commit(progressIndicator);
                }
            }

            return(true);
        }
Пример #14
0
        public static IEnumerable <IMethod> FindAllHierarchy([NotNull] this IMethod method, [CanBeNull] IProgressIndicator pi = null)
        {
            var finder = method
                         .GetPsiServices()
                         .Finder;

            return(InnerFindAllHierarchy(finder, method, pi ?? NullProgressIndicator.Create()));
        }
        public static IReference[] FindReferences([NotNull] this ITreeNode treeNode, [NotNull] IDeclaredElement declaredElement)
        {
            IPsiServices psiServices = treeNode.GetPsiServices();

            return(psiServices.Finder.FindReferences(
                       declaredElement,
                       psiServices.SearchDomainFactory.CreateSearchDomain(treeNode),
                       NullProgressIndicator.Create()
                       ));
        }
Пример #16
0
 private string GetTextAfterFormatting([NotNull] IDocument document, [NotNull] ITextControl textControl)
 {
     using (Solution.GetComponent <DocumentTransactionManager>()
            .CreateTransactionCookie(DefaultAction.Rollback, "Temporary change"))
     {
         var file                = document.GetPsiSourceFile(Solution);
         var codeCleanup         = CodeCleanup.GetInstance(Solution);
         var codeCleanupSettings = Shell.Instance.GetComponent <CodeCleanupSettingsComponent>();
         var profile             = codeCleanupSettings.GetDefaultProfile(CodeCleanup.DefaultProfileType.REFORMAT);
         var selectionRange      = textControl.Selection.OneDocRangeWithCaret();
         codeCleanup.Run(file, selectionRange.Length > 0
                                 ? new DocumentRange(textControl.Document, selectionRange)
                                 : DocumentRange.InvalidRange, profile, NullProgressIndicator.Create());
         return(document.GetText());
     }
 }
Пример #17
0
        private static IReadOnlyCollection <IIssue> RunInspections(ISolution solution, IEnumerable <IPsiSourceFile> sourceFiles)
        {
            var issues = new List <IIssue>();

            using (var lifetime = Lifetimes.Define(solution.GetLifetime()))
                using (var nullProgressIndicator = NullProgressIndicator.Create())
                {
                    var collectInspectionResults = new CollectInspectionResults(solution, lifetime, nullProgressIndicator);

                    collectInspectionResults.RunLocalInspections(
                        new Stack <IPsiSourceFile>(sourceFiles),
                        issuePointers => issues.AddRange(issuePointers));
                }

            return(issues);
        }
Пример #18
0
        private bool IsHandlerExists(Lifetime lifetime, int projectId, string className, string methodName)
        {
            var indicator = NullProgressIndicator.CreateCancellable(lifetime);

            using (TryReadLockCookie.Create(indicator, _locks,
                                            () => !lifetime.IsAlive || _locks.ContentModelLocks.IsWriteLockRequested))
            {
                var project = _projectModelViewHost.GetItemById <IProject>(projectId);
                Assertion.AssertNotNull(project, "project instance should not be null");
                _logger.Verbose($"Searching handler with name '{className}.{methodName}' in the project {project}...");

                var psiModules = project.GetPsiModules();
                foreach (var psiModule in psiModules)
                {
                    using (CompilationContextCookie.OverrideOrCreate(psiModule.GetContextFromModule()))
                    {
                        var scope = _symbolCache.GetSymbolScope(psiModule, false, true);

                        var typeElements = scope.GetElementsByQualifiedName(className).OfType <IClass>();
                        foreach (var typeElement in typeElements)
                        {
                            InterruptableActivityCookie.CheckAndThrow(indicator);
                            foreach (var method in typeElement.Methods)
                            {
                                if (method.ShortName != methodName)
                                {
                                    continue;
                                }
                                if (!LambdaFinder.IsSuitableLambdaMethod(method))
                                {
                                    continue;
                                }

                                return(true);
                            }
                        }
                    }
                }
            }

            return(false);
        }
        protected override bool TryExecute(IInPlaceGenerator generator, GeneratorExecutionHost executionHost)
        {
            IDocument document = generator.DataProvider.Document;

            bool executed = ExecutionHelpers.TryExecuteGenerator(
                generator,
                out string generatedText,
                out TextRange rangeToDelete,
                out int positionToInsert,
                out IReadOnlyCollection <IUsingDirective> missingUsingDirectives
                );

            if (!executed)
            {
                return(false);
            }

            ISolution solution = generator.DataProvider.Solution;

            using (var progressIndicator = NullProgressIndicator.Create())
            {
                IProjectModelTransactionCookie transaction =
                    solution.CreateTransactionCookie(DefaultAction.Rollback, "T4 Generating file", progressIndicator);
                using (transaction)
                {
                    if (!rangeToDelete.IsEmpty)
                    {
                        document.DeleteText(rangeToDelete);
                    }

                    document.InsertText(positionToInsert, generatedText);

                    var treeTextRange = TreeTextRange.FromLength(new TreeOffset(positionToInsert), generatedText.Length);
                    ExecutionHelpers.FormatFileRangeAndAddUsingDirectives(solution, document, treeTextRange, missingUsingDirectives);

                    transaction.Commit(progressIndicator);
                }
            }

            return(true);
        }
Пример #20
0
        public static IList <TOverridableMember> FindImplementingMembers <TOverridableMember>([NotNull] this TOverridableMember overridableMember, [CanBeNull] IProgressIndicator pi = null)
            where TOverridableMember : class, IOverridableMember
        {
            var found = new List <TOverridableMember>();

            overridableMember
            .GetPsiServices()
            .Finder
            .FindImplementingMembers(overridableMember, overridableMember.GetSearchDomain(),
                                     new FindResultConsumer(findResult =>
            {
                var resultOverridableMember = findResult as FindResultOverridableMember;
                var result = resultOverridableMember?.OverridableMember as TOverridableMember;
                if (result != null)
                {
                    found.Add(result);
                }
                return(FindExecution.Continue);
            }), true, pi ?? NullProgressIndicator.Create());
            return(found);
        }
Пример #21
0
        private static void HighlightReferencesInFile(IDeclaredElement declaredElement, IPsiDocumentRangeView psiDocumentRangeView, HighlightingsConsumer consumer)
        {
            var searchDomain  = SearchDomainFactory.Instance.CreateSearchDomain(psiDocumentRangeView.SortedSourceFiles);
            var elements      = new[] { new DeclaredElementInstance(declaredElement) };
            var searchRequest = new SearchSingleFileDeclaredElementRequest(elements, elements, searchDomain);

            foreach (var occurrence in searchRequest.Search(NullProgressIndicator.Create()) ?? EmptyList <IOccurrence> .InstanceList)
            {
                if (!(occurrence is ReferenceOccurrence referenceOccurrence))
                {
                    continue;
                }

                var primaryReference = referenceOccurrence.PrimaryReference;
                if (primaryReference == null)
                {
                    continue;
                }

                var documentRange = primaryReference.GetDocumentRange();
                consumer.ConsumeHighlighting(HIGHLIGHTING_ID, documentRange);
            }
        }
 public PsiCodeFormattingContext(PsiCodeFormatter psiCodeFormatter, ITreeNode firstNode, ITreeNode lastNode, NullProgressIndicator instance)
   : base(psiCodeFormatter, firstNode, lastNode, instance)
 {
 }
Пример #23
0
        static void Analyze([NotNull] IMethodDeclaration methodDeclaration, [NotNull] IHighlightingConsumer consumer)
        {
            if (!methodDeclaration.IsAsync || !methodDeclaration.IsVoidMethodDeclaration())
            {
                return; // not an "async void" method
            }

            var method = methodDeclaration.DeclaredElement;

            if (method == null)
            {
                return; // cannot analyze
            }

            if (method.GetImmediateSuperMembers().Any())
            {
                consumer.AddHighlighting(
                    new AvoidAsyncVoidHighlighting("'void' method overridden or implemented as 'async void'.", methodDeclaration));
                return;
            }

            // find usages
            var psiServices = method.GetPsiServices();

            Debug.Assert(SearchDomainFactory.Instance != null);

            var solutionSearchDomain = SearchDomainFactory.Instance.CreateSearchDomain(psiServices.Solution, false);
            var references           = psiServices.Finder.FindReferences(method, solutionSearchDomain, NullProgressIndicator.Create());

            if (IsPublicSurfaceArea(method))
            {
                if (references.Length > 0)
                {
                    consumer.AddHighlighting(
                        new AvoidAsyncVoidHighlighting("'async void' public surface area method with detected usages.", methodDeclaration));
                }
                else
                {
                    var implicitUseAnnotationProvider = psiServices.GetCodeAnnotationsCache().GetProvider <ImplicitUseAnnotationProvider>();

                    var useKindFlags = implicitUseAnnotationProvider.IsImplicitlyUsed(method);
                    if (useKindFlags == null)
                    {
                        // [UsedImplicitly] annotation not applied
                        consumer.AddHighlighting(
                            new AvoidAsyncVoidHighlighting("'async void' public surface area method without detected usages.", methodDeclaration));
                    }
                }
            }
            else
            {
                var count = references.Count(reference => !reference.AssertNotNull().IsEventTarget());
                if (count > 0)
                {
                    consumer.AddHighlighting(
                        new AvoidAsyncVoidHighlighting(
                            string.Format(
                                "'async void' method used {0} time{1} not as a direct event handler.",
                                count.ToString(),
                                count == 1 ? "" : "s"),
                            methodDeclaration));
                }
            }
        }
Пример #24
0
        public async void Execute(ISolution solution, ITextControl textControl)
        {
            if (this.ExistingProjectFile != null)
            {
                await ShowProjectFile(solution, this.ExistingProjectFile, null);

                return;
            }

            using (ReadLockCookie.Create())
            {
                string         testClassName;
                string         testNamespace;
                string         testFileName;
                IProjectFolder testFolder;
                Template       testFileTemplate;

                using (var cookie = solution.CreateTransactionCookie(DefaultAction.Rollback, this.Text, NullProgressIndicator.Create()))
                {
                    var declaration = this._provider.GetSelectedElement <ICSharpTypeDeclaration>();

                    var declaredType = declaration?.DeclaredElement;
                    if (declaredType == null)
                    {
                        return;
                    }

                    var settingsStore  = declaration.GetSettingsStore();
                    var helperSettings = ReSharperHelperSettings.GetSettings(settingsStore);

                    var testProject = this.CachedTestProject ?? this.ResolveTargetTestProject(declaration, solution, helperSettings);
                    if (testProject == null)
                    {
                        return;
                    }

                    var classNamespaceParts = TrimDefaultProjectNamespace(declaration.GetProject().NotNull(), declaredType.GetContainingNamespace().QualifiedName);
                    var testFolderLocation  = classNamespaceParts.Aggregate(testProject.Location, (current, part) => current.Combine(part));

                    testNamespace = StringUtil.MakeFQName(testProject.GetDefaultNamespace(), StringUtil.MakeFQName(classNamespaceParts));

                    testFolder = testProject.GetOrCreateProjectFolder(testFolderLocation, cookie);
                    if (testFolder == null)
                    {
                        return;
                    }

                    testClassName = declaredType.ShortName + helperSettings.TestClassNameSuffix;
                    testFileName  = testClassName + ".cs";

                    testFileTemplate = StoredTemplatesProvider.Instance.EnumerateTemplates(settingsStore, TemplateApplicability.File).FirstOrDefault(t => t.Description == TemplateDescription);

                    cookie.Commit(NullProgressIndicator.Create());
                }

                if (testFileTemplate != null)
                {
                    await FileTemplatesManager.Instance.CreateFileFromTemplateAsync(testFileName, new ProjectFolderWithLocation(testFolder), testFileTemplate);

                    return;
                }

                var newFile = AddNewItemHelper.AddFile(testFolder, testFileName);
                if (newFile == null)
                {
                    return;
                }

                int?caretPosition = -1;
                solution.GetPsiServices()
                .Transactions.Execute(this.Text, () =>
                {
                    var psiSourceFile = newFile.ToSourceFile();

                    var csharpFile = psiSourceFile?.GetDominantPsiFile <CSharpLanguage>() as ICSharpFile;
                    if (csharpFile == null)
                    {
                        return;
                    }

                    var elementFactory = CSharpElementFactory.GetInstance(csharpFile);

                    var namespaceDeclaration = elementFactory.CreateNamespaceDeclaration(testNamespace);
                    var addedNs = csharpFile.AddNamespaceDeclarationAfter(namespaceDeclaration, null);

                    var classLikeDeclaration = (IClassLikeDeclaration)elementFactory.CreateTypeMemberDeclaration("public class $0 {}", testClassName);
                    var addedTypeDeclaration = addedNs.AddTypeDeclarationAfter(classLikeDeclaration, null) as IClassDeclaration;

                    caretPosition = addedTypeDeclaration?.Body?.GetDocumentRange().TextRange.StartOffset + 1;
                });

                await ShowProjectFile(solution, newFile, caretPosition);
            }
        }
Пример #25
0
 private void DoUnderTransaction(string command, Action action)
 {
     // Create a transaction - Rider will hook the file system and cause the VFS to refresh
     using (WriteLockCookie.Create())
         using (myMetaFileTracker.mySolution.CreateTransactionCookie(DefaultAction.Commit, command, NullProgressIndicator.Create()))
             action();
 }
Пример #26
0
 public PsiCodeFormattingContext(PsiCodeFormatter psiCodeFormatter, ITreeNode firstNode, ITreeNode lastNode, NullProgressIndicator instance)
     : base(psiCodeFormatter, firstNode, lastNode, instance)
 {
 }
Пример #27
0
        protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
        {
            var changeSignature = LanguageManager.Instance.TryGetService <ChangeSignature>(myMethodDeclaration.Language);

            if (changeSignature == null)
            {
                return(null);
            }

            var model = changeSignature.CreateModel(myMethodDeclaration.DeclaredElement);

            for (var i = 0; i < myMethodSignature.Parameters.Length; i++)
            {
                var requiredParameter = myMethodSignature.Parameters[i];

                var modelParameter = FindBestMatch(requiredParameter, model, i);
                if (modelParameter != null)
                {
                    model.MoveTo(modelParameter.OriginalParameterIndex, i);
                }
                else
                {
                    model.Add(i);
                    modelParameter = model.ChangeSignatureParameters[i];
                }

                modelParameter.ParameterName = requiredParameter.Name;
                modelParameter.ParameterKind = ParameterKind.VALUE;
                modelParameter.ParameterType = requiredParameter.Type;

                // Reset everything else
                modelParameter.DefaultValue = null;
                modelParameter.IsOptional   = false;
                modelParameter.IsParams     = false;
                modelParameter.IsThis       = false;
                modelParameter.IsVarArg     = false;
            }

            for (var i = model.ChangeSignatureParameters.Length - 1; i >= myMethodSignature.Parameters.Length; i--)
            {
                model.Remove(i);
            }

            var refactoring = new ChangeSignatureRefactoring(model);

            refactoring.Execute(NullProgressIndicator.Create());

            // Ideally, we would now call InplaceRefactoringsManager.Reset to make sure we didn't have
            // an inplace refactoring highlight. But InplaceRefactoringsManager is internal, so we can't.
            // We don't want a highlight telling us to "apply signature change refactoring" because we
            // just have. The only way to remove it is to fire the Escape action
            return(tc =>
            {
                var highlightingManager = solution.GetComponent <InplaceRefactoringsHighlightingManager>();
                if (highlightingManager.GetHighlightersForTests(tc).Any())
                {
                    var actionManager = solution.GetComponent <IActionManager>();
                    var escapeActionHandler = actionManager.Defs.GetActionDef <EscapeActionHandler>();
                    escapeActionHandler.EvaluateAndExecute(actionManager);
                }
            });
        }