public override void Accept( ITextControl textControl, DocumentRange nameRange, LookupItemInsertType insertType, Suffix suffix, ISolution solution, bool keepCaretStill) { var psiServices = solution.GetPsiServices(); var updateMethodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (!Info.ShouldGenerateMethod) { UpdateExistingMethod(updateMethodDeclaration, psiServices); return; } var isCoroutine = updateMethodDeclaration?.TypeUsage is IUserTypeUsage userTypeUsage && userTypeUsage.ScalarTypeName?.ShortName == "IEnumerator"; var fixedNameRange = nameRange.SetStartTo(Info.MemberReplaceRanges.InsertRange.StartOffset); var memberRange = Info.MemberReplaceRanges.GetAcceptRange(fixedNameRange, insertType); // Insert a dummy method declaration, as text, which means the PSI is reparsed. This will remove empty type // usages and merge leading attributes into a method declaration, such that we can copy them and replace // them once the declared element has expanded. This also fixes up the case where the type usage picks up // the attribute of the next code construct as an array specifier. E.g. `OnAni{caret} [SerializeField]` using (WriteLockCookie.Create()) { textControl.Document.ReplaceText(memberRange, "void Foo(){}"); } psiServices.Files.CommitAllDocuments(); var methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (methodDeclaration == null) { return; } var methodDeclarationCopy = methodDeclaration.Copy(); var nodesBeforeCopyRange = NodesBeforeMethodHeader(methodDeclarationCopy); using (new PsiTransactionCookie(psiServices, DefaultAction.Commit, "RemoveInsertedDeclaration")) using (WriteLockCookie.Create()) { LowLevelModificationUtil.DeleteChild(methodDeclaration); } var classDeclaration = TextControlToPsi.GetElement <IClassLikeDeclaration>(solution, textControl); Assertion.AssertNotNull(classDeclaration, "classDeclaration != null"); var factory = CSharpElementFactory.GetInstance(classDeclaration); GenerateCodeWorkflowBase.ExecuteNonInteractive( GeneratorUnityKinds.UnityEventFunctions, solution, textControl, methodDeclaration.Language, configureContext: context => { // Note that the generated code will use the access rights, if specified. However, if they haven't // been specified (NONE) or they are the default for methods (PRIVATE), the generated code will be // whatever the current code style setting is - implicit or explicit var knownTypesCache = solution.GetComponent <KnownTypesCache>(); var declaredElement = myEventFunction.CreateDeclaration(factory, knownTypesCache, classDeclaration, myAccessRights, makeCoroutine: isCoroutine) .DeclaredElement.NotNull("declaredElement != null"); context.InputElements.Clear(); context.InputElements.Add(new GeneratorDeclaredElement(declaredElement)); }, onCompleted: context => { if (nodesBeforeCopyRange.IsEmpty) { return; } foreach (var outputElement in context.OutputElements) { if (outputElement is GeneratorDeclarationElement declarationElement) { using (new PsiTransactionCookie(psiServices, DefaultAction.Commit, "BringBackAttributes")) using (WriteLockCookie.Create()) { var newDeclaration = declarationElement.Declaration; ModificationUtil.AddChildRangeAfter(newDeclaration, anchor: null, nodesBeforeCopyRange); } return; } } }); ITreeRange NodesBeforeMethodHeader(IMethodDeclaration declaration) { var firstNode = declaration.ModifiersList ?? declaration.TypeUsage as ITreeNode; var smthBeforeTypeUsage = firstNode?.PrevSibling; if (smthBeforeTypeUsage == null) { return(TreeRange.Empty); } return(new TreeRange(declaration.FirstChild, smthBeforeTypeUsage)); } }
private void Accept(ITextControl textControl, IRangeMarker rangeMarker, ISolution solution) { var psiServices = solution.GetPsiServices(); // Get the node at the caret. This will be the identifier var identifierNode = TextControlToPsi.GetElement <ITreeNode>(solution, textControl); if (identifierNode == null) { return; } // Delete the half completed identifier node. Also delete any explicitly entered // return type, as our declared element will create one anyway if (!(identifierNode.GetPreviousMeaningfulSibling() is ITypeUsage typeUsage)) { // E.g. `void OnAnim{caret} [SerializeField]...` This is parsed as a field with an array specifier var fieldDeclaration = identifierNode.GetContainingNode <IFieldDeclaration>(); typeUsage = fieldDeclaration?.GetPreviousMeaningfulSibling() as ITypeUsage; } using (var cookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "RemoveIdentifier")) using (new DisableCodeFormatter()) { using (WriteLockCookie.Create()) { ModificationUtil.DeleteChild(identifierNode); if (typeUsage != null) { ModificationUtil.DeleteChild(typeUsage); } } cookie.Commit(); } // Insert a dummy method declaration, as text, which means the PSI is reparsed. // This will remove empty type usages and merge leading attributes into a method // declaration, such that we can copy them and replace them once the declared // element has expanded. This also fixes up the case where the type usage picks // up the attribute of the next code construct as an array specifier. // E.g. `OnAni{caret} [SerializeField]` using (WriteLockCookie.Create()) textControl.Document.InsertText(rangeMarker.DocumentRange.StartOffset, "void Foo(){}"); psiServices.Files.CommitAllDocuments(); var methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (methodDeclaration == null) { return; } var attributeList = methodDeclaration.FirstChild as IAttributeSectionList; using (var cookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "RemoveInsertedDeclaration")) using (new DisableCodeFormatter()) { using (WriteLockCookie.Create()) ModificationUtil.DeleteChild(methodDeclaration); cookie.Commit(); } // Get the UnityEventFunction generator to actually insert the methods GenerateCodeWorkflowBase.ExecuteNonInteractive( GeneratorUnityKinds.UnityEventFunctions, solution, textControl, identifierNode.Language, configureContext: context => { var inputElements = from e in context.ProvidedElements.Cast <GeneratorDeclaredElement <IMethod> >() where myEventFunction.Match(e.DeclaredElement) != MethodSignatureMatch.NoMatch select e; context.InputElements.Clear(); context.InputElements.AddRange(inputElements); }); if (attributeList != null) { methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (methodDeclaration != null) { using (var transactionCookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "InsertAttributes")) { methodDeclaration.SetAttributeSectionList(attributeList); transactionCookie.Commit(); } } } }
public override void Accept(ITextControl textControl, TextRange nameRange, LookupItemInsertType lookupItemInsertType, Suffix suffix, ISolution solution, bool keepCaretStill) { var rangeMarker = nameRange.CreateRangeMarkerWithMappingToDocument(textControl.Document); var identifierNode = TextControlToPsi.GetElement <ITreeNode>(solution, textControl); var psiServices = solution.GetPsiServices(); if (identifierNode != null) { IErrorElement errorElement = null; ITreeNode usage = identifierNode.GetContainingNode <IUserTypeUsage>(); if (usage != null) { errorElement = usage.NextSibling as IErrorElement; } else { usage = identifierNode.PrevSibling; while (usage != null && !(usage is ITypeUsage)) { usage = usage.PrevSibling; } errorElement = identifierNode.NextSibling as IErrorElement; } using (var cookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "RemoveIdentifier")) using (new DisableCodeFormatter()) { using (WriteLockCookie.Create()) { ModificationUtil.DeleteChild(identifierNode); if (usage != null) { ModificationUtil.DeleteChild(usage); } if (errorElement != null) { ModificationUtil.DeleteChild(errorElement); } } cookie.Commit(); } } using (WriteLockCookie.Create()) { textControl.Document.InsertText(rangeMarker.Range.StartOffset, "void Foo(){}"); } psiServices.Files.CommitAllDocuments(); var methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (methodDeclaration == null) { return; } var insertionIndex = methodDeclaration.GetTreeStartOffset().Offset; string attributeText = null; var attributeList = methodDeclaration.FirstChild as IAttributeSectionList; if (attributeList != null) { attributeText = attributeList.GetText(); var treeNode = attributeList.NextSibling; while (treeNode is IWhitespaceNode) { attributeText += treeNode.GetText(); treeNode = treeNode.NextSibling; } } using (var cookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "RemoveInsertedDeclaration")) using (new DisableCodeFormatter()) { using (WriteLockCookie.Create()) ModificationUtil.DeleteChild(methodDeclaration); cookie.Commit(); } // Get the UniteMessages generator to actually insert the methods GenerateCodeWorkflowBase.ExecuteNonInteractive( GeneratorUnityKinds.UnityMessages, solution, textControl, methodDeclaration.Language, configureContext: context => { var inputElements = from e in context.ProvidedElements.Cast <GeneratorDeclaredElement <IMethod> >() where myMessage.Match(e.DeclaredElement) select e; context.InputElements.Clear(); context.InputElements.AddRange(inputElements); }); if (!string.IsNullOrEmpty(attributeText)) { using (WriteLockCookie.Create()) textControl.Document.InsertText(insertionIndex, attributeText); } }
private void Accept(ITextControl textControl, DocumentRange nameRange, ISolution solution) { var psiServices = solution.GetPsiServices(); // Get the node at the caret. This will be the identifier var identifierNode = TextControlToPsi.GetElement <ITreeNode>(solution, textControl) as IIdentifier; if (identifierNode == null) { return; } var methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (UpdateExistingMethod(methodDeclaration, psiServices)) { return; } // Delete the half completed identifier node. Also delete any explicitly entered return type, as our // declared element will create one anyway if (!(identifierNode.GetPreviousMeaningfulSibling() is ITypeUsage typeUsage)) { // E.g. `void OnAnim{caret} [SerializeField]...` This is parsed as a field with an array specifier var fieldDeclaration = identifierNode.GetContainingNode <IFieldDeclaration>(); typeUsage = fieldDeclaration?.GetPreviousMeaningfulSibling() as ITypeUsage; } var parameterListStart = methodDeclaration?.LPar; var parameterListEnd = methodDeclaration?.RPar; using (var cookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "RemoveIdentifier")) using (new DisableCodeFormatter()) { using (WriteLockCookie.Create()) { ModificationUtil.DeleteChild(identifierNode); if (typeUsage != null) { nameRange = nameRange.Shift(-typeUsage.GetTextLength()); ModificationUtil.DeleteChild(typeUsage); // Also delete the parameter list, if there is one. If there was an existing method declaration, // with parameter list and body, we would have fixed it by simply replacing the name. Deleting // an existing parameter list allows rewriting the return type, method name, parameter list and // body if (parameterListStart != null && parameterListEnd != null) { ModificationUtil.DeleteChildRange(parameterListStart, parameterListEnd); } else if (parameterListStart != null) { ModificationUtil.DeleteChild(parameterListStart); } else if (parameterListEnd != null) { ModificationUtil.DeleteChild(parameterListEnd); } } } cookie.Commit(); } // Insert a dummy method declaration, as text, which means the PSI is reparsed. This will remove empty type // usages and merge leading attributes into a method declaration, such that we can copy them and replace // them once the declared element has expanded. This also fixes up the case where the type usage picks up // the attribute of the next code construct as an array specifier. E.g. `OnAni{caret} [SerializeField]` using (WriteLockCookie.Create()) textControl.Document.InsertText(nameRange.StartOffset, "void Foo(){}"); psiServices.Files.CommitAllDocuments(); methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (methodDeclaration == null) { return; } var attributeList = methodDeclaration.FirstChild as IAttributeSectionList; using (var cookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "RemoveInsertedDeclaration")) using (new DisableCodeFormatter()) { using (WriteLockCookie.Create()) ModificationUtil.DeleteChild(methodDeclaration); cookie.Commit(); } var classDeclaration = TextControlToPsi.GetElement <IClassLikeDeclaration>(solution, textControl); Assertion.AssertNotNull(classDeclaration, "classDeclaration != null"); var factory = CSharpElementFactory.GetInstance(classDeclaration); // Get the UnityEventFunction generator to actually insert the methods GenerateCodeWorkflowBase.ExecuteNonInteractive( GeneratorUnityKinds.UnityEventFunctions, solution, textControl, identifierNode.Language, configureContext: context => { // Note that the generated code will use the access rights, if specified. However, if they haven't // been specified (NONE) or they are the default for methods (PRIVATE), the generated code will be // whatever the current code style setting is - implicit or explicit var declaredElement = myEventFunction.CreateDeclaration(factory, classDeclaration, myAccessRights) .DeclaredElement.NotNull("declaredElement != null"); context.InputElements.Clear(); context.InputElements.Add(new GeneratorDeclaredElement(declaredElement)); }, onCompleted: context => { if (attributeList == null) { return; } methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl); if (methodDeclaration == null) { return; } // The Generate workflow adds a helper function to the queue to select the contents of the method. // Unfortunately, the offsets are calculated before adding the callback to the queue. If we modify // the PSI directly here, the offsets are incorrect and the selection is wrong. Doing it this way // loses the selection, but at least everything works. // Technically, we should probably add the attributes during the generation method, but then we'd // lose how multiple attributes are split into sections, etc. myShellLocks.Queue(Lifetime.Eternal, "FinishDeclaration", () => { using (ReadLockCookie.Create()) using (var transactionCookie = new PsiTransactionCookie(psiServices, DefaultAction.Rollback, "FinishDeclaration")) { methodDeclaration.SetAttributeSectionList(attributeList); transactionCookie.Commit(); } }); }); }