public ILexerFactory GetMixedLexerFactory(IBuffer buffer, IPsiSourceFile sourceFile, PsiManager manager) { var LanguageService = RaconteurLanguage.Instance.LanguageService(); return LanguageService == null ? null : LanguageService.GetPrimaryLexerFactory(); }
/// <summary> /// Creates a reflector with the specified PSI manager. /// </summary> /// <param name="psiManager">The PSI manager.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="psiManager"/> is null.</exception> public PsiReflectionPolicy(PsiManager psiManager) { if (psiManager == null) throw new ArgumentNullException("psiManager"); this.psiManager = psiManager; }
/// <summary> /// Performs the QuickFix, ensures the file is both writable and creates a transaction. /// </summary> /// <param name="solution"> /// Current Solution. /// </param> /// <param name="progress"> /// Progress Indicator for the fix. /// </param> /// <returns> /// The execute transaction. /// </returns> protected override Action <ITextControl> ExecuteTransaction(ISolution solution, JB::JetBrains.Application.Progress.IProgressIndicator progress) { return(delegate(ITextControl textControl) { DocumentManager.GetInstance(solution).SaveAllDocuments(); using (DocumentManager.GetInstance(solution).EnsureWritable()) { PsiManager.GetInstance(solution).DoTransaction(() => this.ExecuteWriteLockableTransaction(solution, textControl)); } }); }
private ICSharpFile GetCodeFile(string fileName) { PsiManager manager = PsiManager.GetInstance(Solution); IProjectFile projectFile = Project.GetAllProjectFiles(file => file.Name.Equals(fileName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault(); if (projectFile != null) { return(manager.GetPsiFile(projectFile.ToSourceFile(), CSharpLanguage.Instance) as ICSharpFile); } return(null); }
/// <summary> /// Initializes a new instance of the <see cref="T4FileDataCache"/> class. /// </summary> /// <param name="lifetime">The lifetime of this class.</param> /// <param name="psiManager">The PSI manager.</param> /// <param name="directiveInfoManager">An instance of <see cref="DirectiveInfoManager"/>.</param> public T4FileDataCache([NotNull] Lifetime lifetime, [NotNull] PsiManager psiManager, [NotNull] DirectiveInfoManager directiveInfoManager) { _directiveInfoManager = directiveInfoManager; _fileDataChanged = new Signal <Pair <IPsiSourceFile, T4FileDataDiff> >(lifetime, "T4FileDataCache.FileDataChanged"); lifetime.AddBracket( () => psiManager.PsiFileCreated += OnPsiFileChanged, () => psiManager.PsiFileCreated -= OnPsiFileChanged); lifetime.AddBracket( () => psiManager.PhysicalPsiChanged += OnPhysicalPsiChanged, () => psiManager.PhysicalPsiChanged -= OnPhysicalPsiChanged); lifetime.AddDispose(_fileDataBySourceFile); }
private void UpdateUI() { Shell.Instance.Invocator.ReentrancyGuard.ExecuteOrQueue("AddDependencyPage.UpdateUI", delegate { if (IsDisposed) { return; } using (ReadLockCookie.Create()) PsiManager.GetInstance(_solution).CommitAllDocuments(); FormValidator.GetInstance(this).Update(); }); }
/// <summary> /// Performs the QuickFix, ensures the file is both writable and creates a transaction. /// </summary> /// <param name="solution"> /// Current Solution. /// </param> /// <param name="progress"> /// Progress Indicator for the fix. /// </param> /// <returns> /// The execute transaction. /// </returns> protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, JB::JetBrains.Application.Progress.IProgressIndicator progress) { return(delegate(ITextControl textControl) { solution.GetComponent <DocumentManagerOperations>().SaveAllDocuments(); using ( JB::JetBrains.Util.ITransactionCookie documentTransaction = solution.GetComponent <DocumentTransactionManager>().CreateTransactionCookie(JB::JetBrains.Util.DefaultAction.Commit, "action name")) { PsiManager.GetInstance(solution).DoTransaction(() => this.ExecuteWriteLockableTransaction(solution, textControl), "Code cleanup"); } }); }
public void Process(IPsiSourceFile sourceFile, IRangeMarker rangeMarkerMarker, CodeCleanupProfile profile, IProgressIndicator progressIndicator) { ISolution solution = sourceFile.GetSolution(); if (!profile.GetSetting(OurDescriptor)) { return; } IPsiFile[] files = sourceFile.GetPsiFiles <PsiLanguage>().Cast <IPsiFile>().ToArray(); using (progressIndicator.SafeTotal("Reformat Psi", files.Length)) { foreach (IPsiFile file in files) { using (IProgressIndicator pi = progressIndicator.CreateSubProgress(1)) { using (WriteLockCookie.Create()) { var languageService = file.Language.LanguageService(); Assertion.Assert(languageService != null, "languageService != null"); var formatter = languageService.CodeFormatter; Assertion.Assert(formatter != null, "formatter != null"); PsiManager.GetInstance(sourceFile.GetSolution()).DoTransaction( delegate { if (rangeMarkerMarker != null && rangeMarkerMarker.IsValid) { formatter.Format( solution, rangeMarkerMarker.DocumentRange, CodeFormatProfile.DEFAULT, true, false, pi); } else { formatter.FormatFile( file, CodeFormatProfile.DEFAULT, pi); } }, "Code cleanup"); } } } } }
public override IDeclaredElement GetDeclaredElement() { ISolution solution = GetSolution(); if (solution == null) { return(null); } using (ReadLockCookie.Create()) { DeclarationsCacheScope scope = DeclarationsCacheScope.SolutionScope(solution, false); IDeclarationsCache cache = PsiManager.GetInstance(solution).GetDeclarationsCache(scope, true); return(cache.GetTypeElementByCLRName(GetTypeClrName())); } }
protected ITypeElement GetDeclaredType() { ISolution solution = GetSolution(); if (solution == null) { return(null); } using (ReadLockCookie.Create()) { IDeclarationsScope scope = DeclarationsScopeFactory.SolutionScope(solution, false); IDeclarationsCache cache = PsiManager.GetInstance(solution).GetDeclarationsCache(scope, true); return(cache.GetTypeElementByCLRName(_declaringTypeName)); } }
protected ITypeElement GetDeclaredType() { IProject project = GetProject(); if (project == null) { return(null); } PsiManager manager = PsiManager.GetInstance(project.GetSolution()); using (ReadLockCookie.Create()) { IDeclarationsCache declarationsCache = manager.GetDeclarationsCache(DeclarationsScopeFactory.ModuleScope(PsiModuleManager.GetInstance(project.GetSolution()).GetPrimaryPsiModule(project), true), true); return(declarationsCache.GetTypeElementByCLRName(myTypeName)); } }
public override void SetUp() { base.SetUp(); WrapperAssert.SupportsSpecialFeatures = false; WrapperAssert.SupportsSpecialName = false; WrapperAssert.SupportsCallingConventions = false; WrapperAssert.SupportsReturnAttributes = false; WrapperAssert.SupportsEventFields = false; WrapperAssert.SupportsGenericParameterAttributes = false; WrapperAssert.SupportsFinalizers = false; WrapperAssert.SupportsStaticConstructors = false; // compiler generated static constructors introduced by static readonly fields are not supported PsiManager manager = PsiManager.GetInstance(SolutionManager.Instance.CurrentSolution); reflectionPolicy = new PsiReflectionPolicy(manager); }
public void Execute(ISolution solution, ITextControl textControl) { using (ReadLockCookie.Create()) { var manager = PsiManager.GetInstance(solution); manager.CommitAllDocuments(); IProjectItem parentFolder = GetParentFolder(_sourceTypeDeclaration); MoveToOuterFile(); IProjectItem sourceFile = GetSourceFile(parentFolder, _sourceTypeDeclaration); IProjectFile newFile = MoveFileToProject(sourceFile); OpenFileInEditor(solution, newFile); sourceFile.Remove(); } }
private void UpdateUI() { var shellLocks = Shell.Instance.GetComponent <IShellLocks>(); shellLocks.ReentrancyGuard.ExecuteOrQueue( "AddDependencyPage.UpdateUI", delegate { if (IsDisposed) { return; } using (ReadLockCookie.Create()) PsiManager.GetInstance(_solution).CommitAllDocuments(); Shell.Instance.GetComponent <FormValidators>().GetOrCreate(this).Update(); }); }
protected ITypeElement GetDeclaredType() { IProject project = GetProject(); if (project == null) { return(null); } using (ReadLockCookie.Create()) { var solution = GetSolution(); var module = PsiModuleManager.GetInstance(solution).GetPsiModule(GetProject().ProjectFile); IDeclarationsScope scope = DeclarationsScopeFactory.ModuleScope(module, true); IDeclarationsCache declarationsCache = PsiManager.GetInstance(solution).GetDeclarationsCache(scope, true); return(declarationsCache.GetTypeElementByCLRName(myTypeName)); } }
/// <summary> /// Executes the process. /// The process should check for <see cref="P:JetBrains.ReSharper.Daemon.IDaemonProcess.InterruptFlag"/> periodically (with intervals less than 100 ms) /// and throw <see cref="T:JetBrains.Application.Progress.ProcessCancelledException"/> if it is true. /// Failing to do so may cause the program to prevent user from typing while analysing the code. /// Stage results should be passed to <param name="commiter"/>. If DaemonStageResult is <c>null</c>, it means that no highlightings available /// </summary> public void Execute(Action <DaemonStageResult> commiter) { if (DaemonProcess.InterruptFlag) { return; } PsiManager manager = PsiManager.GetInstance(DaemonProcess.Solution); var sourceFile = manager.GetPsiFile(DaemonProcess.SourceFile, CSharpLanguage.Instance) as ICSharpFile; if (sourceFile != null) { List <INamingConsistencyChecker> list = LanguageManager.Instance.GetServices <INamingConsistencyChecker>(sourceFile.Language).Where(x => x.IsApplicable(DaemonProcess.SourceFile)).ToList(); list.ForEach(Console.WriteLine); var highlights = new List <HighlightingInfo>(); // highlight field declarations var processor = new RecursiveElementProcessor <IFieldDeclaration>( declaration => { DocumentRange docRange = declaration.GetNameDocumentRange(); highlights.Add(new HighlightingInfo(docRange, new NameInfoHighlighting(declaration))); }); sourceFile.ProcessDescendants(processor); // highlight local var declarations var localVarsProcessor = new RecursiveElementProcessor <ILocalVariableDeclaration>( declaration => { DocumentRange docRange = declaration.GetNameDocumentRange(); highlights.Add(new HighlightingInfo(docRange, new NameInfoHighlighting(declaration))); }); sourceFile.ProcessDescendants(localVarsProcessor); commiter(new DaemonStageResult(highlights)); } }
private bool FileIsValid() { PsiManager manager = PsiManager.GetInstance(this.daemonProcess.Solution); if (!this.daemonProcess.SourceFile.ToProjectFile().IsValid()) { return(false); } IFile file = this.daemonProcess.SourceFile.GetPsiFile(CSharpLanguage.Instance); if (file == null) { return(false); } bool hasErrorElements = new RecursiveElementCollector <ErrorElement>().ProcessElement(file).GetResults().Any(); return(!hasErrorElements); }
private bool ReferenceModuleImpl([NotNull] IPsiModule module, [NotNull] IPsiModule moduleToReference, [CanBeNull] string ns) { if (!CanReferenceModule(module, moduleToReference)) { return(false); } var t4PsiModule = (T4PsiModule)module; var assembly = (IAssembly)moduleToReference.ContainingProjectModule; Assertion.AssertNotNull(assembly, "assembly != null"); var t4File = t4PsiModule.SourceFile.GetNonInjectedPsiFile <T4Language>() as IT4File; if (t4File == null) { return(false); } Action action = () => { // add assembly directive AddDirective(t4File, _directiveInfoManager.Assembly.CreateDirective(assembly.FullAssemblyName)); // add import directive if necessary if (!String.IsNullOrEmpty(ns) && !t4File.GetDirectives(_directiveInfoManager.Import).Any(d => String.Equals(ns, d.GetAttributeValue(_directiveInfoManager.Import.NamespaceAttribute.Name), StringComparison.Ordinal))) { AddDirective(t4File, _directiveInfoManager.Import.CreateDirective(ns)); } }; PsiManager psiManager = PsiManager.GetInstance(module.GetSolution()); if (psiManager.HasActiveTransaction) { action(); return(true); } return(psiManager.DoTransaction(action, "T4 Assembly Reference").Succeded); }
public void ExecuteTemplate() { IDeclaration newDeclaration = myDeclaration; newDeclaration.AssertIsValid(); ISolution solution = newDeclaration.GetPsiModule().GetSolution(); Shell.Instance.Invocator.Dispatcher.AssertAccess(); Assertion.Assert(!PsiManager.GetInstance(solution).HasActiveTransaction, "PSI transaction is active"); solution.GetComponent <SolutionDocumentTransactionManager>().AssertNotUnderTransaction(); IFile file = myAnchor.GetContainingFile(); Assertion.Assert(file != null, "file!= null"); var item = file.GetSourceFile().ToProjectFile(); var infos = GetFieldInfos(newDeclaration, myHolders); var textControl = EditorManager.GetInstance(solution).OpenProjectFile(item, true, TabOptions.DefaultTab); if (textControl == null) { if (Shell.Instance.IsInInternalMode || Shell.Instance.IsTestShell) { Logger.Fail("textControl != null"); } return; } if (infos.Length > 0) { HotspotSession hotspotSession = LiveTemplatesManager.Instance.CreateHotspotSessionAtopExistingText(solution, TextRange.InvalidRange, textControl, LiveTemplatesManager.EscapeAction.LeaveTextAndCaret, infos); hotspotSession.Execute(); } Shell.Instance.GetComponent <PsiIntentionResultBehavior>().OnHotspotSessionExecutionStarted(this, textControl); }
/// <summary> /// This code changes PSI documents. It is executed usder PSI transaction, Command cookies, Reentrancy guard ets. /// All documents are committed (PSI is valid). /// </summary> public override bool Execute(IProgressIndicator pi) { pi.Start(6); //check if data stored in workflow is valid... Method = Workflow.MethodPointer.FindDeclaredElement(); Parameter = Workflow.ParameterPointer.FindDeclaredElement(); if (Method == null || Parameter == null) { return(false); } IPsiServices services = Parameter.GetPsiServices(); IReference[] referencesToParameter; IReference[] referencesToRootOverrides; // search for method overrides (OverridesFinder is util class that // allows to find all overrides and problems with quasi implementations) OverridesFinder overridesFinder = OverridesFinder.CreateInstance(Method); using (var subPi = new SubProgressIndicator(pi, 1)) overridesFinder.Find(subPi); JetHashSet <HierarchyMember> hierarchyMembers = overridesFinder.Overrides; List <IMethod> methods = ScanHierarchyConflicts(hierarchyMembers).ToList(); List <IParameter> parameters = GetAllParameters(methods).ToList(); // find parameters and methods usages... using (var subPi = new SubProgressIndicator(pi, 1)) { subPi.TaskName = "Searching parameter usages:"; IEnumerable <IPsiSourceFile> projectFiles = from param in parameters let projectFilesOfOneParameter = param.GetSourceFiles() from projectFile in projectFilesOfOneParameter select projectFile; ISearchDomain searchDomain = mySearchDomainFactory.CreateSearchDomain(projectFiles.ToList()); referencesToParameter = services.Finder.FindReferences(parameters, searchDomain, subPi); } using (var subPi = new SubProgressIndicator(pi, 1)) { subPi.TaskName = "Searching method usages:"; referencesToRootOverrides = services.Finder.FindReferences(methods, mySearchDomainFactory.CreateSearchDomain(Solution, false), subPi); } // this step processes method usages, removes argument and stores reference specific data to the 'MethodInvocation'. List <MethodInvocation> usages; using (var subPi = new SubProgressIndicator(pi, 1)) usages = PreProcessMethodUsages(referencesToRootOverrides, subPi).ToList(); // replace usages of parameters with typeof(TNewTypeParameter) expression. using (var subPi = new SubProgressIndicator(pi, 1)) ProcessParameterUsages(referencesToParameter, subPi); // Remove parameters from method declarations and insert new type parmeter. Map contains method -> new type parameter relation. Dictionary <IMethod, ITypeParameter> map = UpdateDeclarations(methods); // We have changed declarations. cashes should be updated) PsiManager.GetInstance(Solution).UpdateCaches(); // Process method usages one more time to insert correct type arguments to the call. using (var subPi = new SubProgressIndicator(pi, 1)) BindUsages(usages, map, subPi); return(true); }
private void RegisterPsiChanged([NotNull] Lifetime lifetime, [NotNull] PsiManager psiFiles) { lifetime.AddBracket( () => psiFiles.PhysicalPsiChanged += OnPsiChanged, () => psiFiles.PhysicalPsiChanged -= OnPsiChanged); }
public ILexerFactory GetMixedLexerFactory(IBuffer buffer, IPsiSourceFile sourceFile, PsiManager manager) { var LanguageService = RaconteurLanguage.Instance.LanguageService(); return(LanguageService == null ? null : LanguageService.GetPrimaryLexerFactory()); }
protected bool ConfigureService() { Logger.Info <SactaProxy>("Configurando Servicio"); cfgManager.Get((cfg => { // Se utiliza 'siempre' version 0 para CD30 y version 1 para ULISES. cfg.ProtocolVersion = Properties.Settings.Default.ScvType; History.Configure(cfg.General.HistoryMaxDays, cfg.General.HistoryMaxItems); Managers.Clear(); cfg.Psi.Sectorization.Positions = ""; cfg.Psi.Sectorization.Sectors = ""; cfg.Psi.Sectorization.Virtuals = ""; var manager = new PsiManager(cfg.ProtocolVersion, cfg.Psi, () => History); manager.EventActivity += OnPsiEventActivity; manager.EventSectRequest += OnPsiEventSectorizationAsk; Managers.Add(new DependencyControl(cfg.Psi.Id) { IsMain = true, Cfg = cfg.Psi, Manager = manager }); cfg.Dependencies.ForEach(dep => { var dependency = new ScvManager(cfg.ProtocolVersion, dep, () => History); dependency.EventActivity += OnScvEventActivity; dependency.EventSectorization += OnScvEventSectorization; /** Construyendo la configuracion de Sectorizacion general */ var sectorsMap = dep.Sectorization.SectorsMap.Split(',') .Where(i => Configuration.MapOfSectorsEntryValid(i)) .ToDictionary(k => int.Parse(k.Split(':')[0]), v => int.Parse(v.Split(':')[1])); var positionsMap = dep.Sectorization.PositionsMap.Split(',') .Where(i => Configuration.MapOfSectorsEntryValid(i)) .ToDictionary(k => int.Parse(k.Split(':')[0]), v => int.Parse(v.Split(':')[1])); var virtuals = Configuration.ListString2String( dep.Sectorization.VirtualsList() .Select(v => sectorsMap.Keys.Contains(v) ? sectorsMap[v].ToString() : v.ToString()) .ToList()); var reals = String.Join(",", dep.Sectorization.SectorsList() .Select(r => sectorsMap.Keys.Contains(r) ? sectorsMap[r].ToString() : r.ToString()) .ToList()); //.Aggregate((i, j) => i + "," + j.ToString()); var positions = String.Join(",", dep.Sectorization.PositionsList() .Select(p => positionsMap.Keys.Contains(p) ? positionsMap[p].ToString() : p.ToString()) .ToList()); //.Aggregate((i, j) => i + "," + j.ToString()); cfg.Psi.Sectorization.Positions = Configuration.AgreggateString(cfg.Psi.Sectorization.Positions, positions); cfg.Psi.Sectorization.Virtuals = Configuration.AgreggateString(cfg.Psi.Sectorization.Virtuals, virtuals); cfg.Psi.Sectorization.Sectors = Configuration.AgreggateString(cfg.Psi.Sectorization.Sectors, reals); Managers.Add(new DependencyControl(dep.Id) { IsMain = false, Cfg = dep, Manager = dependency, SectorsMap = sectorsMap, PositionsMap = positionsMap }); }); /** Test de la configuracion que maneja la PSI, que debe coincidir con la configurada en BD */ SectorizationHelper.CompareWithDb(cfg.Psi.Sectorization.Positions, cfg.Psi.Sectorization.Sectors, cfg.Psi.Sectorization.Virtuals, (error) => { // Marcar el Warning... PS.SignalWarning <SactaProxy>($"Incoherencia de Configuración con Base de Datos: {error}", History); }); /** */ var ids = cfg.Dependencies.Select(d => d.Id).ToList(); ids.Add(cfg.Psi.Id); SectorizationPersistence.Sanitize(ids); Cfg = cfg; cfgManager.Write(Cfg); Logger.Info <SactaProxy>("Servicio Configurado..."); })); return(true); }
private static IEnumerable <ICSharpFile> GetAllCSharpFilesInProject(IPsiModule projectModule) { PsiManager psiManager = projectModule.GetPsiServices().PsiManager; return(projectModule.SourceFiles.SelectMany(f => psiManager.GetPsiFiles <CSharpLanguage>(f).OfType <ICSharpFile>())); }
private void DoSmartIndentOnEnter(ITextControl textControl) { var originalOffset = textControl.Caret.Offset(); var offset = TextControlToLexer(textControl, originalOffset); var mixedLexer = GetCachingLexer(textControl); // if there is something on that line, then use existing text if (offset <= 0 || !mixedLexer.FindTokenAt(offset - 1)) { return; } if (mixedLexer.TokenType == PsiTokenType.C_STYLE_COMMENT || mixedLexer.TokenType == PsiTokenType.STRING_LITERAL) { return; } if (offset <= 0 || !mixedLexer.FindTokenAt(offset)) { return; } while (mixedLexer.TokenType == PsiTokenType.WHITE_SPACE) { mixedLexer.Advance(); } offset = mixedLexer.TokenType == null ? offset : mixedLexer.TokenStart; var extraText = (mixedLexer.TokenType == PsiTokenType.NEW_LINE || mixedLexer.TokenType == null) ? "foo " : String.Empty; var projectItem = textControl.Document.GetPsiSourceFile(Solution); if (projectItem == null || !projectItem.IsValid()) { return; } using (PsiManager.GetInstance(Solution).DocumentTransactionManager.CreateTransactionCookie(DefaultAction.Commit, "Typing assist")) { // If the new line is empty, the do default indentation int lexerOffset = offset; if (extraText.Length > 0) { textControl.Document.InsertText(lexerOffset, extraText); } PsiServices.PsiManager.CommitAllDocuments(); var file = projectItem.GetPsiFile <PsiLanguage>(new DocumentRange(textControl.Document, offset)); if (file == null) { return; } var rangeInJsTree = file.Translate(new DocumentOffset(textControl.Document, offset)); if (!rangeInJsTree.IsValid()) { if (extraText.Length > 0) { textControl.Document.DeleteText(new TextRange(lexerOffset, lexerOffset + extraText.Length)); } return; } var tokenNode = file.FindTokenAt(rangeInJsTree) as ITokenNode; if (tokenNode == null) { if (extraText.Length > 0) { textControl.Document.DeleteText(new TextRange(lexerOffset, lexerOffset + extraText.Length)); } return; } PsiCodeFormatter codeFormatter = GetCodeFormatter(file); int offsetInToken = rangeInJsTree.Offset - tokenNode.GetTreeStartOffset().Offset; using (PsiTransactionCookie.CreateAutoCommitCookieWithCachesUpdate(PsiServices, "Typing assist")) { Lifetimes.Using( lifetime => { var boundSettingsStore = SettingsStore.CreateNestedTransaction(lifetime, "PsiTypingAssist").BindToContextTransient(textControl.ToContextRange()); var prevToken = tokenNode.GetPrevToken(); if (prevToken == null) { return; } if (tokenNode.Parent is IParenExpression || prevToken.Parent is IParenExpression) { var node = tokenNode.Parent; if (prevToken.Parent is IParenExpression) { node = prevToken.Parent; } codeFormatter.Format(node.FirstChild, node.LastChild, CodeFormatProfile.DEFAULT, NullProgressIndicator.Instance, boundSettingsStore); } else { codeFormatter.Format(prevToken, tokenNode, CodeFormatProfile.INDENT, NullProgressIndicator.Instance, boundSettingsStore); } }); offset = file.GetDocumentRange(tokenNode.GetTreeStartOffset()).TextRange.StartOffset + offsetInToken; } if (extraText.Length > 0) { lexerOffset = offset; textControl.Document.DeleteText(new TextRange(lexerOffset, lexerOffset + extraText.Length)); } } textControl.Caret.MoveTo(offset, CaretVisualPlacement.DontScrollIfVisible); }
public bool Execute(IProgressIndicator progressIndicator) { var ctor = _ctor.FindDeclaredElement(); if (ctor == null) { return(false); } var definingClass = _class.FindDeclaredElement(); if (definingClass == null) { return(false); } if (ctor.Module == null) { return(false); } var factory = CSharpElementFactory.GetInstance(ctor.Module); var ctorDecl = ctor.GetDeclarations().FirstOrDefault(); if (ctorDecl == null) { var typeDecl = definingClass.GetDeclarations().FirstOrDefault() as IClassLikeDeclarationNode; if (typeDecl == null) { return(false); } var typeBody = typeDecl.Body; ctorDecl = factory.CreateTypeMemberDeclaration("public $0() {}", typeDecl.DeclaredName); if (typeBody.FirstChild == null) { return(false); } if (ctorDecl == null) { return(false); } ctorDecl = ModificationUtil.AddChildBefore( typeBody, typeBody.FirstChild.NextSibling, ctorDecl.ToTreeNode()).GetContainingElement <IConstructorDeclaration>(true); } if (ctorDecl == null) { return(false); } var type = CSharpTypeFactory.CreateType(_parameterType, ctorDecl.ToTreeNode()); if (!type.IsResolved) { type = CSharpTypeFactory.CreateType(_parameterType, ctorDecl.GetPsiModule()); } string recommendedName = null; var naming = PsiManager.GetInstance(_solution).Naming; if (!type.IsResolved) { var presentableName = type.GetPresentableName(CSharpLanguageService.CSHARP); var indexOfGeneric = presentableName.IndexOf('<'); if (indexOfGeneric != -1) { var interfaceName = presentableName.Substring(1, indexOfGeneric - 1); var genericArgument = presentableName.Substring(indexOfGeneric).Trim('<', '>'); recommendedName = naming.Suggestion.GetDerivedName( genericArgument + interfaceName, NamedElementKinds.Parameters, ScopeKind.Common, CSharpLanguageService.CSHARP, new SuggestionOptions()); } var interfaceDecl = factory.CreateTypeMemberDeclaration("public interface IFoo {}"); if (interfaceDecl == null) { return(false); } interfaceDecl.SetName(presentableName); interfaceDecl.LanguageService.CodeFormatter.Format(interfaceDecl.ToTreeNode(), CodeFormatProfile.GENERATOR); var containingType = ctor.GetContainingType(); if (containingType == null) { return(false); } var containingTypeDecl = containingType.GetDeclarations().First(); ModificationUtil.AddChildBefore(containingTypeDecl.ToTreeNode(), interfaceDecl.ToTreeNode()); } type = CSharpTypeFactory.CreateType(_parameterType, ctorDecl.ToTreeNode()); if (recommendedName == null) { var suggestionOptions = new SuggestionOptions(); recommendedName = naming.Suggestion.GetDerivedName( type.GetPresentableName(CSharpLanguageService.CSHARP), NamedElementKinds.Parameters, ScopeKind.Common, CSharpLanguageService.CSHARP, suggestionOptions); } var parametersOwner = ctorDecl as ICSharpParametersOwnerDeclaration; var references = FindReferences(parametersOwner, progressIndicator); if (parametersOwner == null) { return(false); } parametersOwner.AddParameterDeclarationAfter( ParameterKind.VALUE, type, recommendedName, parametersOwner.ParameterDeclarations.LastOrDefault()); foreach (var reference in references) { ChangeReference(reference, recommendedName, type); } return(true); }