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()); } }
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); } } } }
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); } } } }
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); }
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); } }
public void TestNullProgressIndicatorComplete() { NullProgressIndicator np = new NullProgressIndicator(); np.Complete(); Assert.AreEqual("", standardOut.ToString()); }
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)); } }
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); }
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() )); }
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()); } }
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); }
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); }
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); }
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) { }
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)); } } }
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); } }
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(); }
public PsiCodeFormattingContext(PsiCodeFormatter psiCodeFormatter, ITreeNode firstNode, ITreeNode lastNode, NullProgressIndicator instance) : base(psiCodeFormatter, firstNode, lastNode, instance) { }
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); } }); }