コード例 #1
0
 public override bool TryFix(ConstructFixer fixer, SyntaxNode syntaxTree, Ide.Gui.Document document, int location, ref int newOffset)
 {
     foreach (var breakStatementSyntax in syntaxTree.FindToken(location).Parent.AncestorsAndSelf().OfType <BreakStatementSyntax> ())
     {
         if (breakStatementSyntax.SemicolonToken.IsMissing)
         {
             var insertionOffset = breakStatementSyntax.Span.End - 1;
             newOffset = insertionOffset;
             newOffset++;
             document.Editor.InsertText(insertionOffset, ";");
             return(true);
         }
     }
     foreach (var breakStatementSyntax in syntaxTree.FindToken(location).Parent.AncestorsAndSelf().OfType <ContinueStatementSyntax> ())
     {
         if (breakStatementSyntax.SemicolonToken.IsMissing)
         {
             var insertionOffset = breakStatementSyntax.Span.End - 1;
             newOffset = insertionOffset;
             newOffset++;
             document.Editor.InsertText(insertionOffset, ";");
             return(true);
         }
     }
     return(false);
 }
コード例 #2
0
        internal static async Task <List <TextLink> > GetTextLinksAsync(Ide.Gui.Document doc, int caretOffset, ISymbol symbol)
        {
            var links = new List <TextLink> ();
            var link  = new TextLink("name");

            var documents = ImmutableHashSet.Create(doc.DocumentContext.AnalysisDocument);

            foreach (var loc in symbol.Locations)
            {
                if (loc.IsInSource && FilePath.PathComparer.Equals(loc.SourceTree.FilePath, doc.FileName))
                {
                    link.AddLink(new TextSegment(loc.SourceSpan.Start, loc.SourceSpan.Length));
                }
            }

            foreach (var mref in await SymbolFinder.FindReferencesAsync(symbol, doc.DocumentContext.AnalysisDocument.Project.Solution, documents, default(CancellationToken)))
            {
                foreach (var loc in mref.Locations)
                {
                    var span    = loc.Location.SourceSpan;
                    var segment = new TextSegment(span.Start, span.Length);
                    if (segment.Offset <= caretOffset && caretOffset <= segment.EndOffset)
                    {
                        link.Links.Insert(0, segment);
                    }
                    else
                    {
                        link.AddLink(segment);
                    }
                }
            }
            links.Add(link);
            return(links);
        }
コード例 #3
0
        public DocumentJitter()
        {
            IdeApp.Workbench.ActiveDocumentChanged += Workbench_ActiveDocumentChanged;

            doc = IdeApp.Workbench.ActiveDocument;
            //Update();
        }
コード例 #4
0
        public override bool TryFix(ConstructFixer fixer, SyntaxNode syntaxTree, Ide.Gui.Document document, int location, ref int newOffset)
        {
            foreach (var invocationExpression in syntaxTree.FindToken(location).Parent.AncestorsAndSelf().OfType <InvocationExpressionSyntax> ())
            {
                if (invocationExpression != null)
                {
                    if (!invocationExpression.ArgumentList.OpenParenToken.IsMissing && invocationExpression.ArgumentList.CloseParenToken.IsMissing)
                    {
                        var insertionOffset = invocationExpression.Span.End - 1;

                        newOffset = insertionOffset;

                        var text = ")";
                        newOffset++;
                        var expressionStatement = invocationExpression.Parent as ExpressionStatementSyntax;
                        if (expressionStatement != null)
                        {
                            if (expressionStatement.SemicolonToken.IsMissing)
                            {
                                text = ");";
                            }
                            newOffset++;
                        }
                        document.Editor.InsertText(insertionOffset, text);
                        return(true);
                    }
                }
            }
            return(false);
        }
コード例 #5
0
        static async Task <Tuple <CodeActionEditorExtension, Projects.Solution> > GatherFixesNoDispose <T> (string input, Action <ResultsEditorExtension, TaskCompletionSource <T> > callback, params int[] caretLocations)
        {
            await Ide.Composition.CompositionManager.InitializeAsync();

            TestWorkbenchWindow tww     = new TestWorkbenchWindow();
            TestViewContent     content = new TestViewContent();

            tww.ViewContent       = content;
            content.ContentName   = "/a.cs";
            content.Data.MimeType = "text/x-csharp";

            var doc = new Ide.Gui.Document(tww);

            var text = input;

            content.Text = text;

            var project = Projects.Services.ProjectService.CreateProject("C#");

            project.Name     = "test";
            project.FileName = "test.csproj";
            project.Files.Add(new ProjectFile(content.ContentName, BuildAction.Compile));
            var solution = new Projects.Solution();

            solution.AddConfiguration("", true);
            solution.DefaultSolutionFolder.AddItem(project);
            content.Project = project;
            doc.SetProject(project);

            using (var monitor = new ProgressMonitor())
                await TypeSystemService.Load(solution, monitor);

            var resultsExt = new ResultsEditorExtension();

            resultsExt.Initialize(doc.Editor, doc);
            content.Contents.Add(resultsExt);

            var compExt = new CodeActionEditorExtension();

            compExt.Initialize(doc.Editor, doc);
            content.Contents.Add(compExt);

            var tcs = new TaskCompletionSource <T> ();

            var cts = new CancellationTokenSource();

            cts.CancelAfter(60 * 1000);
            cts.Token.Register(() => tcs.TrySetCanceled());

            resultsExt.TasksUpdated += delegate {
                callback(resultsExt, tcs);
            };

            await doc.UpdateParseDocument();

            await Task.Run(() => tcs.Task);

            return(Tuple.Create(compExt, solution));
        }
コード例 #6
0
        internal static async Task <ISymbol> GetSymbolAtCaret(Ide.Gui.Document doc, CancellationToken cancelToken = default)
        {
            if (doc == null || doc.Editor == null)
            {
                return(null);
            }
            var info = await RefactoringSymbolInfo.GetSymbolInfoAsync(doc.DocumentContext, doc.Editor, cancelToken);

            return(info.Symbol ?? info.DeclaredSymbol);
        }
コード例 #7
0
        internal static async Task <ISymbol> GetSymbolAtCaret(Ide.Gui.Document doc)
        {
            if (doc == null)
            {
                return(null);
            }
            var info = await RefactoringSymbolInfo.GetSymbolInfoAsync(doc, doc.Editor);

            return(info.Symbol ?? info.DeclaredSymbol);
        }
コード例 #8
0
ファイル: DCodeFormatter.cs プロジェクト: FrankLIKE/Mono-D
        // CorrectIndenting is completely unused in the entire MonoDevelopment code environment - doesn't have to be implemented

        /// <summary>
        /// Used for formatting selected code
        /// </summary>
        public override void OnTheFlyFormat(Ide.Gui.Document _doc, int startOffset, int endOffset)
        {
            var doc = _doc.Editor.Document;

            DFormattingPolicy policy    = null;
            TextStylePolicy   textStyle = null;

            if (_doc.HasProject)
            {
                policy    = _doc.Project.Policies.Get <DFormattingPolicy>(Indentation.DTextEditorIndentation.mimeTypes);
                textStyle = _doc.Project.Policies.Get <TextStylePolicy>(Indentation.DTextEditorIndentation.mimeTypes);
            }
            else
            {
                policy    = PolicyService.GetDefaultPolicy <DFormattingPolicy> (Indentation.DTextEditorIndentation.mimeTypes);
                textStyle = PolicyService.GetDefaultPolicy <TextStylePolicy> (Indentation.DTextEditorIndentation.mimeTypes);
            }

            if (IndentCorrectionOnly)
            {
                using (doc.OpenUndoGroup())
                    using (var r = doc.CreateReader())
                        D_Parser.Formatting.Indent.IndentEngineWrapper.CorrectIndent(r,
                                                                                     startOffset, endOffset,
                                                                                     doc.Replace, policy.Options,
                                                                                     new TextStyleAdapter(textStyle)
                        {
                            KeepAlignmentSpaces = policy.KeepAlignmentSpaces
                        });
                return;
            }

            var dpd = _doc.ParsedDocument as ParsedDModule;

            if (dpd == null)
            {
                return;
            }

            var formattingVisitor = new DFormattingVisitor(policy.Options, new DocAdapt(doc), dpd.DDom, new TextStyleAdapter(textStyle));

            formattingVisitor.CheckFormattingBoundaries = true;
            var dl = doc.OffsetToLocation(startOffset);

            formattingVisitor.FormattingStartLocation = new CodeLocation(dl.Column, dl.Line);
            dl = doc.OffsetToLocation(endOffset);
            formattingVisitor.FormattingEndLocation = new CodeLocation(dl.Column, dl.Line);

            formattingVisitor.WalkThroughAst();

            using (doc.OpenUndoGroup())
                formattingVisitor.ApplyChanges(doc.Replace);
        }
コード例 #9
0
        protected bool TryGetDocument(out Document analysisDocument, out Ide.Gui.Document doc)
        {
            doc = IdeApp.Workbench.ActiveDocument;
            if (doc == null || doc.FileName == null || doc.Editor == null)
            {
                analysisDocument = null;
                return(false);
            }

            analysisDocument = doc.DocumentContext?.AnalysisDocument;
            return(doc != null);
        }
コード例 #10
0
            static Projects.Project DetermineRealProject(Ide.Gui.Document doc)
            {
                // try to search for a shared project
                var allProjects = IdeApp.Workspace.GetAllItems <SharedAssetsProject> ();
                var projects    = new List <SharedAssetsProject> (allProjects.Where(p => p.IsFileInProject(doc.FileName)));

                if (projects.Count > 0)
                {
                    return(projects [0]);
                }

                return(doc.Project);
            }
コード例 #11
0
        public override IEnumerable <CodeAction> GetActions(Ide.Gui.Document document, object refactoringContext, ICSharpCode.NRefactory.TextLocation loc, System.Threading.CancellationToken cancellationToken)
        {
            if (!DLanguageBinding.IsDFile(document.FileName))
            {
                yield break;
            }

            var imports = GetSolutions(document); //it may be a bit too slow

            foreach (var i in imports)
            {
                yield return(new InnerAction(i));
            }
        }
コード例 #12
0
        static async Task <RefactoringSymbolInfo> GetNamedTypeAtCaret(Ide.Gui.Document doc)
        {
            if (doc == null)
            {
                return(null);
            }
            var info = await RefactoringSymbolInfo.GetSymbolInfoAsync(doc, doc.Editor);

            if (info.Node?.Parent.IsKind(SyntaxKind.SimpleBaseType) != true)
            {
                return(null);
            }

            return(info);
        }
コード例 #13
0
        /// <summary>
        /// Looks for open documents that are showing the detail for the service that is being removed and updates the content to show the gallery instead
        /// </summary>
        static void EnsureServiceDetailTabIsClosed(DotNetProject project, string serviceId)
        {
            Ide.Gui.Document view = null;
            var servicesView      = LocateServiceView(project, out view);

            if (servicesView != null)
            {
                var docObject   = view.GetDocumentObject();
                var serviceNode = docObject as ConnectedServiceNode;
                if (serviceNode != null && serviceNode.Id == serviceId)
                {
                    servicesView.UpdateContent(null);
                    view.Window.SelectWindow();
                }
            }
        }
コード例 #14
0
        public static CodeGenerator CreateGenerator(Ide.Gui.Document doc)
        {
            MimeTypeExtensionNode node;

            if (!generators.TryGetValue(doc.Editor.MimeType, out node))
            {
                return(null);
            }

            var result = (CodeGenerator)node.CreateInstance();

            result.UseSpaceIndent = doc.Editor.TabsToSpaces;
            result.EolMarker      = doc.Editor.EolMarker;
            result.TabSize        = doc.Editor.Options.TabSize;
            result.Compilation    = doc.Compilation;
            return(result);
        }
コード例 #15
0
        internal static async Task Run(Ide.Gui.Document doc)
        {
            var selectionRange   = doc.Editor.CaretOffset;
            var analysisDocument = doc.DocumentContext.AnalysisDocument;

            if (analysisDocument == null)
            {
                return;
            }
            var parsedDocument = await analysisDocument.GetSyntaxTreeAsync();

            if (parsedDocument == null)
            {
                return;
            }
            var unit = parsedDocument.GetRoot();

            if (unit == null)
            {
                return;
            }

            var selectionAnnotation = ExpandSelectionHandler.GetSelectionAnnotation(doc.Editor);

            if (selectionAnnotation.Stack.Count == 0)
            {
                return;
            }
            selectionAnnotation.Stack.Pop();
            if (selectionAnnotation.Stack.Count > 0)
            {
                var node = selectionAnnotation.Stack.Peek();
                doc.Editor.SetSelection(node.SpanStart, node.Span.End);
            }
            else
            {
                doc.Editor.ClearSelection();
            }
        }
コード例 #16
0
        internal static async void Run(Ide.Gui.Document doc)
        {
            var selectionRange   = doc.Editor.SelectionRange;
            var analysisDocument = doc.DocumentContext.AnalysisDocument;

            if (analysisDocument == null)
            {
                return;
            }
            var model = await analysisDocument.GetSemanticModelAsync();

            if (model == null)
            {
                return;
            }
            var unit = model.SyntaxTree.GetRoot();
            var node = unit.FindNode(Microsoft.CodeAnalysis.Text.TextSpan.FromBounds(selectionRange.Offset, selectionRange.EndOffset));

            if (node == null)
            {
                return;
            }

            if (doc.Editor.IsSomethingSelected)
            {
                while (node != null && ShrinkSelectionHandler.IsSelected(doc.Editor, node.Span))
                {
                    node = node.Parent;
                }
            }

            if (node != null)
            {
                var selectionAnnotation = GetSelectionAnnotation(doc.Editor);
                selectionAnnotation.Stack.Push(node);
                doc.Editor.SetSelection(node.SpanStart, node.Span.End);
            }
        }
コード例 #17
0
        public override void InsertCompletionText(CompletionListWindow window, ref KeyActions ka, Gdk.Key closeChar, char keyChar, Gdk.ModifierType modifier)
        {
            if (customCompletionText == null)
            {
                if (Node != null && !string.IsNullOrEmpty(Node.Name))
                {
                    base.InsertCompletionText(window, ref ka, closeChar, keyChar, modifier);
                }
                return;
            }

            Ide.Gui.Document guiDoc = null;
            var ed = window.CompletionWidget as SourceEditor.SourceEditorView;

            foreach (var gdoc in Ide.IdeApp.Workbench.Documents)
            {
                if (gdoc.Editor.Document == ed.Document)
                {
                    guiDoc = gdoc;
                    break;
                }
            }

            if (guiDoc == null)
            {
                return;
            }

            var f = new Formatting.DCodeFormatter();
            var insertionOffset = window.CodeCompletionContext.TriggerOffset;

            ed.Document.Insert(insertionOffset, customCompletionText, ICSharpCode.NRefactory.Editor.AnchorMovementType.AfterInsertion);

            guiDoc.UpdateParseDocument();

            f.OnTheFlyFormat(guiDoc, insertionOffset, insertionOffset + customCompletionText.Length);
        }
コード例 #18
0
		public FindMemberOverloadsHandler (Ide.Gui.Document doc, IMember entity)
		{
			this.doc = doc;
			this.entity = entity;
		}
コード例 #19
0
 public FindDerivedSymbolsHandler(Ide.Gui.Document doc, IMember entity)
 {
     //this.doc = doc;
     this.entity = entity;
 }
コード例 #20
0
 protected override void Format(TextEditor editor, Ide.Gui.Document document, int start, int end)
 {
     OnTheFlyFormatter.Format(editor, document, start, end);
 }
コード例 #21
0
        protected static async Task AssertExpectedCodeFixes(ExpectedCodeFixes expected, Ide.Gui.Document doc)
        {
            var fixes = await doc.GetContent <CodeActionEditorExtension> ().GetCurrentFixesAsync(CancellationToken.None);

            var fixActions = fixes.CodeFixActions.SelectMany(x => x.Fixes).OrderBy(f => f.Action.Message).ToArray();

            Assert.AreEqual(expected.CodeFixData.Length, fixActions.Length);
            for (int j = 0; j < expected.CodeFixData.Length; ++j)
            {
                Assert.AreEqual(expected.CodeFixData [j].Message, fixActions [j].Action.Message);
            }

            var fixRefactorings = fixes.CodeRefactoringActions.SelectMany(x => x.Actions).OrderBy(f => f.Message).ToArray();

            Assert.AreEqual(expected.CodeRefactoringData.Length, fixRefactorings.Length);
            for (int j = 0; j < expected.CodeRefactoringData.Length; ++j)
            {
                Assert.AreEqual(expected.CodeRefactoringData [j].Message, fixRefactorings [j].Message);
            }
        }
コード例 #22
0
 public override void Run(Ide.Gui.Document document, ICSharpCode.NRefactory.TextLocation loc)
 {
     ApplySolution(Title, document);
 }
コード例 #23
0
 public FindMemberOverloadsHandler(Ide.Gui.Document doc, IMember entity)
 {
     this.doc    = doc;
     this.entity = entity;
 }
コード例 #24
0
		public FindDerivedSymbolsHandler (Ide.Gui.Document doc, IMember entity)
		{
			this.doc = doc;
			this.entity = entity;
		}
コード例 #25
0
        // CorrectIndenting is completely unused in the entire MonoDevelopment code environment - doesn't have to be implemented

        /// <summary>
        /// Used for format selected code
        /// </summary>
        public override void OnTheFlyFormat(Ide.Gui.Document doc, int startOffset, int endOffset)
        {
            //base.OnTheFlyFormat(doc, startOffset, endOffset);
        }
コード例 #26
0
		public FindExtensionMethodHandler (Ide.Gui.Document doc, ITypeDefinition entity)
		{
			this.doc = doc;
			this.entity = entity;
		}
コード例 #27
0
 protected abstract void Format(TextEditor editor, Ide.Gui.Document document, SnapshotPoint start, SnapshotPoint end);
コード例 #28
0
        protected static void AssertExpectedDiagnostics(IEnumerable <ExpectedDiagnostic> expected, Ide.Gui.Document doc)
        {
            var ext = doc.GetContent <ResultsEditorExtension> ();

            var actualDiagnostics   = ext.QuickTasks;
            var expectedDiagnostics = expected.ToArray();

            Assert.AreEqual(expectedDiagnostics.Length, actualDiagnostics.Length);

            for (int i = 0; i < expectedDiagnostics.Length; ++i)
            {
                AssertExpectedDiagnostic(expectedDiagnostics [i], ext, i);
            }
        }
コード例 #29
0
 //public static Task<bool> InsertMemberWithCursor (string operation, ITypeSymbol type, Location part, SyntaxNode newMember, bool implementExplicit = false)
 //{
 //	//TODO: Add dialog for inserting position
 //	AddNewMember (type, part, newMember, implementExplicit);
 //	return Task.FromResult (true);
 //}
 //
 //		public static int CalculateBodyIndentLevel (IUnresolvedTypeDefinition declaringType)
 //		{
 //			if (declaringType == null)
 //				return 0;
 //			int indentLevel = 1;
 //			while (declaringType.DeclaringTypeDefinition != null) {
 //				indentLevel++;
 //				declaringType = declaringType.DeclaringTypeDefinition;
 //			}
 //			var file = declaringType.UnresolvedFile as CSharpUnresolvedFile;
 //			if (file == null)
 //				return indentLevel;
 //			var scope = file.GetUsingScope (declaringType.Region.Begin);
 //			while (scope != null && !string.IsNullOrEmpty (scope.NamespaceName)) {
 //				indentLevel++;
 //				// skip virtual scopes.
 //				while (scope.Parent != null && scope.Parent.Region == scope.Region)
 //					scope = scope.Parent;
 //				scope = scope.Parent;
 //			}
 //			return indentLevel;
 //		}
 public static MonoDevelop.Ide.TypeSystem.CodeGenerator CreateCodeGenerator(this Ide.Gui.Document doc)
 {
     return(MonoDevelop.Ide.TypeSystem.CodeGenerator.CreateGenerator(doc));
 }
コード例 #30
0
 /// <summary>
 /// Searches for open documents and locates the ConnectedServicesViewContent for the given project
 /// </summary>
 internal static ConnectedServicesViewContent LocateServiceView(DotNetProject project)
 {
     Ide.Gui.Document view = null;
     return(LocateServiceView(project, out view));
 }
コード例 #31
0
        protected void RegisterExtensionCallback <T> (Ide.Gui.Document doc, Action <T> registerCallback) where T : TextEditorExtension
        {
            var ext = doc.GetContent <T> ();

            registerCallback(ext);
        }
コード例 #32
0
 public static CodeGenerator CreateCodeGenerator(this Ide.Gui.Document doc)
 {
     return(CodeGenerator.CreateGenerator(doc));
 }
コード例 #33
0
        /// <summary>
        /// Searches for open documents and locates the ConnectedServicesViewContent for the given project
        /// </summary>
        internal static ConnectedServicesViewContent LocateServiceView(DotNetProject project, out Ide.Gui.Document documentView)
        {
            documentView = null;
            foreach (var view in IdeApp.Workbench.Documents)
            {
                var servicesView = view.PrimaryView.GetContent <ConnectedServicesViewContent> ();
                if (servicesView != null && servicesView.Project == project)
                {
                    documentView = view;
                    return(servicesView);
                }
            }

            return(null);
        }