Пример #1
0
		public static async Task<RefactoringSymbolInfo> GetSymbolInfoAsync (DocumentContext document, int offset, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (document == null)
				throw new ArgumentNullException (nameof (document));
			if (document.ParsedDocument == null)
				return RefactoringSymbolInfo.Empty;
			var unit = await document.AnalysisDocument.GetSemanticModelAsync (cancellationToken).ConfigureAwait (false);
			if (unit != null) {
				var root = await unit.SyntaxTree.GetRootAsync (cancellationToken).ConfigureAwait (false);
				try {
					var token = root.FindToken (offset);
					if (!token.Span.IntersectsWith (offset))
						return RefactoringSymbolInfo.Empty;
					var symbol = unit.GetSymbolInfo (token.Parent);
					return new RefactoringSymbolInfo (symbol) {
						DeclaredSymbol = token.IsKind (SyntaxKind.IdentifierToken) ? unit.GetDeclaredSymbol (token.Parent) : null,
						Node = token.Parent,
						Model = unit
					};
				} catch (Exception) {
					return RefactoringSymbolInfo.Empty;
				}
			}
			return RefactoringSymbolInfo.Empty;
		}
		public override bool CheckOpeningPoint(TextEditor editor, DocumentContext ctx, CancellationToken cancellationToken)
		{
			var snapshot = CurrentSnapshot;
			var position = StartOffset;
			var token = FindToken(snapshot, position, cancellationToken);

			// check token at the opening point first
			if (!IsValidToken(token) ||
			    token.RawKind != OpeningTokenKind ||
			    token.SpanStart != position || token.Parent == null)
			{
				return false;
			}

			// now check whether parser think whether there is already counterpart closing parenthesis
			var pair = token.Parent.GetParentheses();

			// if pair is on the same line, then the closing parenthesis must belong to other tracker.
			// let it through
			if (Editor.GetLineByOffset (pair.Item1.SpanStart).LineNumber == Editor.GetLineByOffset(pair.Item2.Span.End).LineNumber)
			{
				return true;
			}

			return (int)pair.Item2.Kind() != ClosingTokenKind || pair.Item2.Span.Length == 0;
		}
		public ProjectedDocumentContext (TextEditor projectedEditor, DocumentContext originalContext)
		{
			if (projectedEditor == null)
				throw new ArgumentNullException ("projectedEditor");
			if (originalContext == null)
				throw new ArgumentNullException ("originalContext");
			this.projectedEditor = projectedEditor;
			this.originalContext = originalContext;

			if (originalContext.Project != null) {
				var originalProjectId = TypeSystemService.GetProjectId (originalContext.Project);
				if (originalProjectId != null) {
					var originalProject = TypeSystemService.Workspace.CurrentSolution.GetProject (originalProjectId);
					if (originalProject != null) {
						projectedDocument = originalProject.AddDocument (
							projectedEditor.FileName,
							projectedEditor
						);
					}
				}
			}

			projectedEditor.TextChanged += delegate(object sender, TextChangeEventArgs e) {
				if (projectedDocument != null)
					projectedDocument = projectedDocument.WithText (projectedEditor);
				ReparseDocument ();
			};

			ReparseDocument ();
		}
Пример #4
0
		void HandleDocumentContextChanged (object sender, EventArgs e)
		{
			if (currentContext != null)
				currentContext.DocumentParsed -= HandleDocumentParsed;
			currentContext = textEditor.DocumentContext;
			currentContext.DocumentParsed += HandleDocumentParsed;
		}
		public override bool IsValidInContext (DocumentContext context)
		{
			var pctx = context as ProjectedDocumentContext;
			if (pctx == null)
				return false;
			return pctx.ProjectedEditor.GetContent<CompletionTextEditorExtension> () != null;
		}
		public ProjectedCompletionExtension (DocumentContext ctx, IReadOnlyList<Projection> projections)
		{
			if (projections == null)
				throw new ArgumentNullException ("projections");
			this.ctx = ctx;
			this.projections = projections;
		}
			public NavigationVisitor (DocumentContext documentContext, SemanticModel model, TextSpan region, CancellationToken token)
			{
				this.documentContext = documentContext;
				this.model = model;
				this.region = region;
				this.token = token;
			}
		public override async Task<TooltipItem> GetItem (TextEditor editor, DocumentContext ctx, int offset, CancellationToken token = default(CancellationToken))
		{
			if (ctx == null)
				return null;
			var analysisDocument = ctx.ParsedDocument;
			if (analysisDocument == null)
				return null;
			var unit = analysisDocument.GetAst<SemanticModel> ();
			if (unit == null)
				return null;
			
			var root = unit.SyntaxTree.GetRoot (token);
			SyntaxToken syntaxToken;
			try {
				syntaxToken = root.FindToken (offset);
			} catch (ArgumentOutOfRangeException) {
				return null;
			}
			if (!syntaxToken.Span.IntersectsWith (offset))
				return null;
			var symbolInfo = unit.GetSymbolInfo (syntaxToken.Parent, token);
			var symbol = symbolInfo.Symbol ?? unit.GetDeclaredSymbol (syntaxToken.Parent, token);
			var tooltipInformation = await CreateTooltip (symbol, syntaxToken, editor, ctx, offset);
			if (tooltipInformation == null || string.IsNullOrEmpty (tooltipInformation.SignatureMarkup))
				return null;
			return new TooltipItem (tooltipInformation, syntaxToken.Span.Start, syntaxToken.Span.Length);
		}
		public override Control CreateTooltipWindow (TextEditor editor, DocumentContext ctx, TooltipItem item, int offset, Xwt.ModifierKeys modifierState)
		{
			var result = new LanguageItemWindow (GetExtensibleTextEditor (editor), modifierState, null, (string)item.Item, null);
			if (result.IsEmpty)
				return null;
			return result;
		}
		public static bool IsContext(TextEditor editor, DocumentContext ctx, int position, CancellationToken cancellationToken)
		{
			// Check to see if we're to the right of an $ or an @$
			var start = position - 1;
			if (start < 0)
			{
				return false;
			}

			if (editor[start] == '@')
			{
				start--;

				if (start < 0)
				{
					return false;
				}
			}

			if (editor[start] != '$')
			{
				return false;
			}

			var tree = ctx.AnalysisDocument.GetSyntaxTreeAsync (cancellationToken).WaitAndGetResult(cancellationToken);
			var token = tree.GetRoot(cancellationToken).FindTokenOnLeftOfPosition(start);

			return tree.IsExpressionContext(start, token, attributes: false, cancellationToken: cancellationToken)
				       || tree.IsStatementContext(start, token, cancellationToken);
		}
		CSharpCompletionTextEditorExtension CreateCompletionAndUpdate (MonoDevelop.Ide.Editor.TextEditor editor, DocumentContext context, UnderlyingDocumentInfo docInfo,
			out CodeCompletionContext codeCompletionContext)
		{
			var completion = CreateCompletion (editor, context, docInfo, out codeCompletionContext);
			completion.UpdateParsedDocument ();
			return completion;
		}
Пример #12
0
		public static void FormatStatmentAt (TextEditor editor, DocumentContext context, MonoDevelop.Ide.Editor.DocumentLocation location, OptionSet optionSet = null)
		{
			var offset = editor.LocationToOffset (location);
			var policyParent = context.Project != null ? context.Project.Policies : PolicyService.DefaultPolicies;
			var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType);
			Format (policyParent, mimeTypeChain, editor, context, offset, offset, false, true, optionSet: optionSet);
		}
		public Task<ICompletionDataList> HandleCompletion (MonoDevelop.Ide.Editor.TextEditor editor, DocumentContext context,	CodeCompletionContext completionContext,
			UnderlyingDocumentInfo docInfo, char currentChar, CancellationToken token)
		{
			CodeCompletionContext ccc;
			var completion = CreateCompletionAndUpdate (editor, context, docInfo, out ccc);
			return completion.HandleCodeCompletionAsync (completionContext, currentChar, token);
		}
Пример #14
0
		static void Format (PolicyContainer policyParent, IEnumerable<string> mimeTypeChain, TextEditor editor, DocumentContext context, int startOffset, int endOffset, bool exact, bool formatLastStatementOnly = false, OptionSet optionSet = null)
		{
			TextSpan span;
			if (exact) {
				span = new TextSpan (startOffset, endOffset - startOffset);
			} else {
				span = new TextSpan (0, endOffset);
			}

			var analysisDocument = context.AnalysisDocument;
			if (analysisDocument == null)
				return;

			using (var undo = editor.OpenUndoGroup (/*OperationType.Format*/)) {
				try {
					var syntaxTree = analysisDocument.GetSyntaxTreeAsync ().Result;

					if (formatLastStatementOnly) {
						var root = syntaxTree.GetRoot ();
						var token = root.FindToken (endOffset);
						var tokens = ICSharpCode.NRefactory6.CSharp.FormattingRangeHelper.FindAppropriateRange (token);
						if (tokens.HasValue) {
							span = new TextSpan (tokens.Value.Item1.SpanStart, tokens.Value.Item2.Span.End - tokens.Value.Item1.SpanStart);
						} else {
							var parent = token.Parent;
							if (parent != null)
								span = parent.FullSpan;
						}
					}

					if (optionSet == null) {
						var policy = policyParent.Get<CSharpFormattingPolicy> (mimeTypeChain);
						var textPolicy = policyParent.Get<TextStylePolicy> (mimeTypeChain);
						optionSet = policy.CreateOptions (textPolicy);
					}

					var doc = Formatter.FormatAsync (analysisDocument, span, optionSet).Result;
					var newTree = doc.GetSyntaxTreeAsync ().Result;
					var caretOffset = editor.CaretOffset;

					int delta = 0;
					foreach (var change in newTree.GetChanges (syntaxTree)) {
						if (!exact && change.Span.Start + delta >= caretOffset)
							continue;
						var newText = change.NewText;
						editor.ReplaceText (delta + change.Span.Start, change.Span.Length, newText);
						delta = delta - change.Span.Length + newText.Length;
					}

					var caretEndOffset = caretOffset + delta;
					if (0 <= caretEndOffset && caretEndOffset < editor.Length)
						editor.CaretOffset = caretEndOffset;
					if (editor.CaretColumn == 1)
						editor.CaretColumn = editor.GetVirtualIndentationColumn (editor.CaretLine);
				} catch (Exception e) {
					LoggingService.LogError ("Error in on the fly formatter", e);
				}
			}
		}
		protected AbstractTokenBraceCompletionSession (DocumentContext ctx,
		                                               int openingTokenKind, int closingTokenKind, char ch)
		{
			this.closingChar = ch;
			this.ctx = ctx;
			this.OpeningTokenKind = openingTokenKind;
			this.ClosingTokenKind = closingTokenKind;
		}
Пример #16
0
 public CodeGenerator(TemplateLoader templateLoader, DocumentContext context,
     GeneratorConfig config, DirectoryInfo outputFolder)
 {
     this.outputFolder = outputFolder;
     this.templateLoader = templateLoader;
     this.contextGenerator = context.TemplateContextGenerator;
     this.config = config;
 }
		public async static Task<IEnumerable<CodeRefactoringDescriptor>> GetCodeRefactoringsAsync (DocumentContext documentContext, string language, CancellationToken cancellationToken = default (CancellationToken))
		{
			var result = new List<CodeRefactoringDescriptor> ();
			foreach (var provider in providers) {
				result.AddRange (await provider.GetCodeRefactoringDescriptorsAsync (documentContext, language, cancellationToken).ConfigureAwait (false));
			}
			return result;
		}
Пример #18
0
		internal void Run (TextEditor editor, DocumentContext ctx)
		{
			var info = RefactoringSymbolInfo.GetSymbolInfoAsync (ctx, editor.CaretOffset).Result;
			var sym = info.DeclaredSymbol ?? info.Symbol;
			if (!CanRename (sym))
				return;
			new RenameRefactoring ().Rename (sym);
		}
		public ProjectedSemanticHighlighting (TextEditor editor, DocumentContext documentContext, IEnumerable<Projection> projections) : base (editor, documentContext)
		{
			this.projections = new List<Projection> (projections);
			foreach (var p in this.projections) {
				if (p.ProjectedEditor.SemanticHighlighting == null)
					continue;
				p.ProjectedEditor.SemanticHighlighting.SemanticHighlightingUpdated += HandleSemanticHighlightingUpdated;
			}
		}
		public override Control CreateTooltipWindow (TextEditor editor, DocumentContext ctx, TooltipItem item, int offset, Xwt.ModifierKeys modifierState)
		{
			var result = item.Item as Result;

			var window = new LanguageItemWindow (CompileErrorTooltipProvider.GetExtensibleTextEditor (editor), modifierState, null, result.Message, null);
			if (window.IsEmpty)
				return null;
			return window;
		}
		public override Control CreateTooltipWindow (TextEditor editor, DocumentContext ctx, TooltipItem item, int offset, Xwt.ModifierKeys modifierState)
		{
			foreach (var pseg in projection.ProjectedSegments) {
				if (pseg.ContainsOriginal (offset)) {
					return projectedTooltipProvider.CreateTooltipWindow (projection.ProjectedEditor, projection.ProjectedContext, item, pseg.FromOriginalToProjected (offset), modifierState);
				}
			}
			return null;
		}
		public override async Task<TooltipItem> GetItem (TextEditor editor, DocumentContext ctx, int offset, CancellationToken token = default(CancellationToken))
		{
			if (offset >= editor.Length)
				return null;

			if (!DebuggingService.IsDebugging || DebuggingService.IsRunning)
				return null;

			StackFrame frame = DebuggingService.CurrentFrame;
			if (frame == null)
				return null;

			var ed = CompileErrorTooltipProvider.GetExtensibleTextEditor (editor);
			if (ed == null)
				return null;
			string expression = null;
			int startOffset;

			if (ed.IsSomethingSelected && offset >= ed.SelectionRange.Offset && offset <= ed.SelectionRange.EndOffset) {
				startOffset = ed.SelectionRange.Offset;
				expression = ed.SelectedText;
			} else {
				var doc = ctx;
				if (doc == null || doc.ParsedDocument == null)
					return null;

				var resolver = doc.GetContent<IDebuggerExpressionResolver> ();
				var data = doc.GetContent<SourceEditorView> ();

				if (resolver != null) {
					var result = await resolver.ResolveExpressionAsync (editor, doc, offset, token);
					expression = result.Text;
					startOffset = result.Span.Start;
				} else {
					int endOffset = data.GetTextEditorData ().FindCurrentWordEnd (offset);
					startOffset = data.GetTextEditorData ().FindCurrentWordStart (offset);

					expression = editor.GetTextAt (startOffset, endOffset - startOffset);
				}
			}
			
			if (string.IsNullOrEmpty (expression))
				return null;

			var options = DebuggingService.DebuggerSession.EvaluationOptions.Clone ();
			options.AllowMethodEvaluation = true;
			options.AllowTargetInvoke = true;

			var val = frame.GetExpressionValue (expression, options);

			if (val == null || val.IsUnknown || val.IsNotSupported)
				return null;
			
			val.Name = expression;
			
			return new TooltipItem (val, startOffset, expression.Length);
		}
		public bool CheckOpeningPoint(TextEditor editor, DocumentContext ctx, CancellationToken cancellationToken)
		{
			var snapshot = ctx.AnalysisDocument.GetSyntaxTreeAsync (cancellationToken).WaitAndGetResult(cancellationToken);
			var position = editor.CaretOffset - 1;
			var token = AbstractTokenBraceCompletionSession.FindToken(snapshot, position, cancellationToken);

			return token.IsKind(SyntaxKind.OpenBraceToken)
				        && token.SpanStart == position;
		}
Пример #24
0
		public TextEditor CreateProjectedEditor (DocumentContext originalContext)
		{
			if (projectedEditor == null) {
				projectedEditor = TextEditorFactory.CreateNewEditor (Document, TextEditorType.Projection);
				projectedDocumentContext = new ProjectedDocumentContext (projectedEditor, originalContext);
				projectedEditor.InitializeExtensionChain (projectedDocumentContext);
				projectedProjections.InstallListener (projectedEditor);
			}
			return projectedEditor;
		}
		public override Task<TooltipItem> GetItem (TextEditor editor, DocumentContext ctx, int offset, CancellationToken token = default (CancellationToken))
		{
			foreach (var marker in editor.GetTextSegmentMarkersAt (offset)) {
				var result = marker.Tag as Result;
				if (result != null) 
					return Task.FromResult(new TooltipItem (result, marker.Offset, marker.Length));
			}
			return Task.FromResult<TooltipItem> (null);

		}
Пример #26
0
		public JSonIndentEngine (TextEditor editor, DocumentContext ctx)
		{
			if (editor == null)
				throw new ArgumentNullException ("editor");
			if (ctx == null)
				throw new ArgumentNullException ("ctx");
			this.editor = editor;
			this.ctx = ctx;
			Reset ();
		}
Пример #27
0
		internal async Task Run (TextEditor editor, DocumentContext ctx)
		{
			var cts = new CancellationTokenSource ();
			var getSymbolTask = RefactoringSymbolInfo.GetSymbolInfoAsync (ctx, editor, cts.Token);
			var message = GettextCatalog.GetString ("Resolving symbol…");
			var info = await MessageService.ExecuteTaskAndShowWaitDialog (getSymbolTask, message, cts);
			var sym = info.DeclaredSymbol ?? info.Symbol;
			if (!CanRename (sym))
				return;
			await new RenameRefactoring ().Rename (sym);
		}
		public async static Task<IEnumerable<CodeDiagnosticDescriptor>> GetCodeDiagnosticsAsync (DocumentContext documentContext, string language, CancellationToken cancellationToken = default (CancellationToken))
		{
			var result = new List<CodeDiagnosticDescriptor> ();

			foreach (var provider in providers) {
				if (cancellationToken.IsCancellationRequested)
					return Enumerable.Empty<CodeDiagnosticDescriptor> ();
				result.AddRange (await provider.GetCodeDiagnosticDescriptorsAsync (documentContext, language, cancellationToken).ConfigureAwait (false));
			}
			return result;
		}
		public override async Task<BraceMatchingResult?> GetMatchingBracesAsync (IReadonlyTextDocument editor, DocumentContext context, int offset, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (context.ParsedDocument == null)
				return await fallback.GetMatchingBracesAsync (editor, context, offset, cancellationToken);

			var analysisDocument = context.AnalysisDocument;
			if (analysisDocument == null)
				return null;
			var partialDoc = await CSharpCompletionTextEditorExtension.WithFrozenPartialSemanticsAsync (analysisDocument, cancellationToken).ConfigureAwait (false);
			var root = await partialDoc.GetSyntaxRootAsync (cancellationToken).ConfigureAwait (false);
			if (offset < 0 || root.Span.End <= offset)
				return null;
			var token = root.FindToken (offset);
			var tokenSpan = token.Span;
			if (offset < tokenSpan.Start || offset >= tokenSpan.End)
				return null;
			for (int i = 0; i < tokenPairs.Length / 2; i++) {
				var open = tokenPairs [i * 2];
				var close = tokenPairs [i * 2 + 1];
				SyntaxToken match;
				if (token.IsKind (open)) {
					if (TryFindMatchingToken (token, out match, open, close)) {
						return new BraceMatchingResult (new TextSegment (tokenSpan.Start, tokenSpan.Length), new TextSegment (match.Span.Start, match.Span.Length), true);
					}
				} else if (token.IsKind (close)) {
					if (TryFindMatchingToken (token, out match, open, close)) {
						return new BraceMatchingResult (new TextSegment (match.Span.Start, match.Span.Length), new TextSegment (tokenSpan.Start, tokenSpan.Length), false);
					}
				}
			}

			if (token.IsKind (SyntaxKind.StringLiteralToken) && token.ToString().EndsWith ("\"", StringComparison.Ordinal)) {
				if (token.IsVerbatimStringLiteral ()) {
					if (offset <= tokenSpan.Start)
						return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 2), new TextSegment (tokenSpan.End - 1, 1), true);
					if (offset >= tokenSpan.End - 1)
						return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 2), new TextSegment (tokenSpan.End - 1, 1), false);
				} else {
					if (offset <= tokenSpan.Start)
						return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), true);
					if (offset >= tokenSpan.End - 1)
						return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), false);
				}
			}

			if (token.IsKind (SyntaxKind.CharacterLiteralToken) && token.ToString().EndsWith ("\'", StringComparison.Ordinal)) {
				if (offset <= tokenSpan.Start)
					return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), true);
				if (offset >= tokenSpan.End - 1)
					return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), false);
			}

			return null;
		}
		public override Task<TooltipItem> GetItem (TextEditor editor, DocumentContext ctx, int offset, CancellationToken token = default(CancellationToken))
		{
			var ed = GetExtensibleTextEditor (editor);
			if (ed == null)
				return Task.FromResult<TooltipItem> (null);

			string errorInformation = ed.GetErrorInformationAt (offset);
			if (string.IsNullOrEmpty (errorInformation))
				return Task.FromResult<TooltipItem> (null);

			return Task.FromResult (new TooltipItem (errorInformation, editor.GetLineByOffset (offset)));
		}
Пример #31
0
        public override async Task <BraceMatchingResult?> GetMatchingBracesAsync(IReadonlyTextDocument editor, DocumentContext context, int offset, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (context.ParsedDocument == null)
            {
                return(await fallback.GetMatchingBracesAsync(editor, context, offset, cancellationToken));
            }

            var analysisDocument = context.AnalysisDocument;

            if (analysisDocument == null)
            {
                return(null);
            }
            var partialDoc = analysisDocument.WithFrozenPartialSemantics(cancellationToken);
            var root       = await partialDoc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

            if (offset < 0 || root.Span.End <= offset)
            {
                return(null);
            }
            var trivia = root.FindTrivia(offset).GetStructure() as DirectiveTriviaSyntax;

            if (trivia != null && (trivia.IsKind(SyntaxKind.RegionDirectiveTrivia) || trivia.IsKind(SyntaxKind.EndRegionDirectiveTrivia)))
            {
                var matching = trivia.GetMatchingDirective(cancellationToken);
                if (matching == null)
                {
                    return(null);
                }
                if (trivia.IsKind(SyntaxKind.RegionDirectiveTrivia))
                {
                    return(new BraceMatchingResult(
                               new TextSegment(trivia.Span.Start, trivia.Span.Length),
                               new TextSegment(matching.Span.Start, matching.Span.Length),
                               true,
                               BraceMatchingProperties.Hidden));
                }
                else
                {
                    return(new BraceMatchingResult(
                               new TextSegment(matching.Span.Start, matching.Span.Length),
                               new TextSegment(trivia.Span.Start, trivia.Span.Length),
                               false,
                               BraceMatchingProperties.Hidden));
                }
            }

            var token     = root.FindToken(offset);
            var tokenSpan = token.Span;

            if (offset < tokenSpan.Start || offset >= tokenSpan.End)
            {
                return(null);
            }
            for (int i = 0; i < tokenPairs.Length / 2; i++)
            {
                var         open  = tokenPairs [i * 2];
                var         close = tokenPairs [i * 2 + 1];
                SyntaxToken match;
                if (token.IsKind(open))
                {
                    if (TryFindMatchingToken(token, out match, open, close))
                    {
                        return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, tokenSpan.Length), new TextSegment(match.Span.Start, match.Span.Length), true));
                    }
                }
                else if (token.IsKind(close))
                {
                    if (TryFindMatchingToken(token, out match, open, close))
                    {
                        return(new BraceMatchingResult(new TextSegment(match.Span.Start, match.Span.Length), new TextSegment(tokenSpan.Start, tokenSpan.Length), false));
                    }
                }
            }

            if (token.IsKind(SyntaxKind.StringLiteralToken) && token.ToString().EndsWith("\"", StringComparison.Ordinal))
            {
                if (token.IsVerbatimStringLiteral())
                {
                    if (offset <= tokenSpan.Start)
                    {
                        return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 2), new TextSegment(tokenSpan.End - 1, 1), true));
                    }
                    if (offset >= tokenSpan.End - 1)
                    {
                        return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 2), new TextSegment(tokenSpan.End - 1, 1), false));
                    }
                }
                else
                {
                    if (offset <= tokenSpan.Start)
                    {
                        return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), true));
                    }
                    if (offset >= tokenSpan.End - 1)
                    {
                        return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), false));
                    }
                }
            }

            if (token.IsKind(SyntaxKind.CharacterLiteralToken) && token.ToString().EndsWith("\'", StringComparison.Ordinal))
            {
                if (offset <= tokenSpan.Start)
                {
                    return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), true));
                }
                if (offset >= tokenSpan.End - 1)
                {
                    return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), false));
                }
            }

            return(null);
        }
 public void CheckShowCodeGenerationWindow(CommandInfo info)
 {
     info.Enabled = Editor != null && DocumentContext.GetContent <ICompletionWidget> () != null;
 }
Пример #33
0
 protected virtual void OnTheFlyFormatImplementation(TextEditor editor, DocumentContext context, int startOffset, int length)
 {
     throw new NotSupportedException("On the fly formatting not supported");
 }
 async Task <DebugDataTipInfo> IDebuggerExpressionResolver.ResolveExpressionAsync(IReadonlyTextDocument editor, DocumentContext doc, int offset, CancellationToken cancellationToken)
 {
     return(await Resolver.DebuggerExpressionResolver.ResolveAsync(editor, doc, offset, cancellationToken).ConfigureAwait(false));
 }
 public IndexController()
 {
     _context = new DocumentContext();
     _context.Database.Migrate();
 }
Пример #36
0
 public override bool IsValidInContext(DocumentContext context)
 {
     return(LanguageBindingService.GetBindingPerFileName(context.Name) != null);
 }
Пример #37
0
        protected async override Task CorrectIndentingImplementationAsync(Ide.Editor.TextEditor editor, DocumentContext context, int startLine, int endLine, CancellationToken cancellationToken)
        {
            if (editor.IndentationTracker == null)
            {
                return;
            }
            var startSegment = editor.GetLine(startLine);

            if (startSegment == null)
            {
                return;
            }
            var endSegment = startLine != endLine?editor.GetLine(endLine) : startSegment;

            if (endSegment == null)
            {
                return;
            }

            try {
                var document = context.AnalysisDocument;

                var formattingService = document.GetLanguageService <IEditorFormattingService> ();
                if (formattingService == null || !formattingService.SupportsFormatSelection)
                {
                    return;
                }

                var formattingRules = new List <AbstractFormattingRule> ();
                formattingRules.Add(ContainedDocumentPreserveFormattingRule.Instance);
                formattingRules.AddRange(Formatter.GetDefaultFormattingRules(document));

                var workspace = document.Project.Solution.Workspace;
                var root      = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

                var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);

                var changes = Formatter.GetFormattedTextChanges(
                    root, new TextSpan [] { new TextSpan(startSegment.Offset, endSegment.EndOffset - startSegment.Offset) },
                    workspace, options, formattingRules, cancellationToken);

                if (changes == null)
                {
                    return;
                }
                await Runtime.RunInMainThread(delegate {
                    editor.ApplyTextChanges(changes);
                    editor.FixVirtualIndentation();
                });
            } catch (Exception e) {
                LoggingService.LogError("Error while indenting", e);
            }
        }
Пример #38
0
 public override bool IsValidInContext(DocumentContext context)
 {
     return(IsFileNameHandled(context.Name) && base.IsValidInContext(context));
 }
Пример #39
0
 public OCCodeGenerator(TemplateLoader templateLoader, DocumentContext context, GeneratorConfig config,
                        DirectoryInfo outputFolder) : base(templateLoader, context, config, outputFolder)
 {
 }
 public CompilationUnitDataProvider(TextEditor editor, DocumentContext documentContext)
 {
     this.editor          = editor;
     this.DocumentContext = documentContext;
 }
 public override bool IsValidInContext(DocumentContext context)
 {
     return(context.GetContent <CSharpCompletionTextEditorExtension> () != null);
 }
 void EnableExtension()
 {
     enabled = true;
     DocumentContext.ReparseDocument();
 }
Пример #43
0
 public ContextActionRunner(TextEditor editor, CodeAction act)
 {
     this.editor     = editor;
     this.act        = act;
     documentContext = editor.DocumentContext;
 }
Пример #44
0
        protected override async void OnTheFlyFormatImplementation(Ide.Editor.TextEditor editor, DocumentContext context, int startOffset, int length)
        {
            var doc = context.AnalysisDocument;

            var formattingService = doc.GetLanguageService <IEditorFormattingService> ();

            if (formattingService == null || !formattingService.SupportsFormatSelection)
            {
                return;
            }

            var changes = await formattingService.GetFormattingChangesAsync(doc, new TextSpan (startOffset, length), default(System.Threading.CancellationToken));

            if (changes == null)
            {
                return;
            }
            editor.ApplyTextChanges(changes);
            editor.FixVirtualIndentation();
        }
Пример #45
0
 static bool SkipContext(DocumentContext ctx)
 {
     return(ctx.IsAdHocProject || !(ctx.Project is MonoDevelop.Projects.DotNetProject));
 }
        public override async Task <TooltipItem> GetItem(TextEditor editor, DocumentContext ctx, int offset, CancellationToken token = default(CancellationToken))
        {
            if (offset >= editor.Length)
            {
                return(null);
            }

            if (!DebuggingService.IsDebugging || DebuggingService.IsRunning)
            {
                return(null);
            }

            StackFrame frame = DebuggingService.CurrentFrame;

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

            var ed = CompileErrorTooltipProvider.GetExtensibleTextEditor(editor);

            if (ed == null)
            {
                return(null);
            }
            string expression = null;
            int    startOffset;

            if (ed.IsSomethingSelected && offset >= ed.SelectionRange.Offset && offset <= ed.SelectionRange.EndOffset)
            {
                startOffset = ed.SelectionRange.Offset;
                expression  = ed.SelectedText;
            }
            else
            {
                var doc = ctx;
                if (doc == null || doc.ParsedDocument == null)
                {
                    return(null);
                }

                var resolver = doc.GetContent <IDebuggerExpressionResolver> ();
                var data     = doc.GetContent <SourceEditorView> ();

                if (resolver != null)
                {
                    var result = await resolver.ResolveExpressionAsync(editor, doc, offset, token);

                    expression  = result.Text;
                    startOffset = result.Span.Start;
                }
                else
                {
                    int endOffset = data.GetTextEditorData().FindCurrentWordEnd(offset);
                    startOffset = data.GetTextEditorData().FindCurrentWordStart(offset);

                    expression = editor.GetTextAt(startOffset, endOffset - startOffset);
                }
            }

            if (string.IsNullOrEmpty(expression))
            {
                return(null);
            }

            var options = DebuggingService.DebuggerSession.EvaluationOptions.Clone();

            options.AllowMethodEvaluation = true;
            options.AllowTargetInvoke     = true;

            var val = frame.GetExpressionValue(expression, options);

            if (val == null || val.IsUnknown || val.IsNotSupported)
            {
                return(null);
            }

            val.Name = expression;

            return(new TooltipItem(val, startOffset, expression.Length));
        }
Пример #47
0
//		public static void SetText (this CompletionData data, string text)
//		{
//			if (data is CompletionData) {
//				((CompletionData)data).CompletionText = text;
//			} else if (data is IEntityCompletionData) {
//				((IEntityCompletionData)data).CompletionText = text;
//			} else {
//				System.Console.WriteLine("Unknown completion data:" + data);
//			}
//		}

//		public static ICSharpCode.NRefactory.CSharp.SyntaxTree Parse (this ICSharpCode.NRefactory.CSharp.CSharpParser parser, IReadonlyTextDocument data)
//		{
//			return parser.Parse (new ICSharpCode.NRefactory.Editor.StringTextSource (data.Text), data.FileName);
//		}

//		public static AstNode ParseSnippet (this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data)
//		{
//			using (var stream = new  StreamReader (data.OpenStream ())) {
//				var result = parser.ParseExpression (stream);
//				if (!parser.HasErrors)
//					return result;
//			}
//			parser.ErrorPrinter.Reset ();
//			using (var stream = new  StreamReader (data.OpenStream ())) {
//				var result = parser.ParseStatements (stream);
//				if (!parser.HasErrors)
//					return result.FirstOrDefault ();
//			}
//			parser.ErrorPrinter.Reset ();
//			using (var stream = data.OpenStream ()) {
//				return parser.Parse (stream, data.Document.FileName);
//			}
//		}

        internal static MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy GetFormattingPolicy(this DocumentContext doc)
        {
            var policyParent = doc?.Project?.Policies;
            var types        = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain(MonoDevelop.CSharp.Formatting.CSharpFormatter.MimeType);
            var codePolicy   = policyParent != null?policyParent.Get <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);

            return(codePolicy);
        }
Пример #48
0
 public TypeVisitor(string javaNamespace, DocumentContext documentContext)
 {
     this.javaNamespace   = javaNamespace;
     this.documentContext = documentContext;
 }
Пример #49
0
 public static OptionSet GetFormattingOptions(this DocumentContext doc)
 {
     return(doc.AnalysisDocument.GetOptionsAsync().WaitAndGetResult(default(CancellationToken)));
 }
 public override Control CreateTooltipWindow(TextEditor editor, DocumentContext ctx, TooltipItem item, int offset, Gdk.ModifierType modifierState)
 {
     return(new DebugValueWindow(editor, offset, DebuggingService.CurrentFrame, (ObjectValue)item.Item, null));
 }
Пример #51
0
        public static async Task <TooltipInformation> GetQuickInfoAsync(TextEditor editor, DocumentContext ctx, ISymbol symbol, CancellationToken cancellationToken = default(CancellationToken))
        {
            var tooltipInfo = new TooltipInformation();

            var model = await ctx.AnalysisDocument.GetSemanticModelAsync();

            var descriptionService = ctx.RoslynWorkspace.Services.GetLanguageServices(model.Language).GetService <ISymbolDisplayService> ();

            var sections = await descriptionService.ToDescriptionGroupsAsync(ctx.RoslynWorkspace, model, editor.CaretOffset, new [] { symbol }.AsImmutable(), default(CancellationToken)).ConfigureAwait(false);

            ImmutableArray <TaggedText> parts;

            var sb = new StringBuilder();

            var theme = editor.Options.GetEditorTheme();

            if (sections.TryGetValue(SymbolDescriptionGroups.MainDescription, out parts))
            {
                TaggedTextUtil.AppendTaggedText(sb, theme, parts);
            }

            // if generating quick info for an attribute, bind to the class instead of the constructor
            if (symbol.ContainingType?.IsAttribute() == true)
            {
                symbol = symbol.ContainingType;
            }

            var formatter     = ctx.RoslynWorkspace.Services.GetLanguageServices(model.Language).GetService <IDocumentationCommentFormattingService> ();
            var documentation = symbol.GetDocumentationParts(model, editor.CaretOffset, formatter, cancellationToken);

            sb.Append("<span font='" + FontService.SansFontName + "' size='small'>");

            if (documentation != null)
            {
                sb.AppendLine();
                sb.AppendLine();
                TaggedTextUtil.AppendTaggedText(sb, theme, documentation);
            }

            if (sections.TryGetValue(SymbolDescriptionGroups.AnonymousTypes, out parts))
            {
                if (!parts.IsDefaultOrEmpty)
                {
                    sb.AppendLine();
                    TaggedTextUtil.AppendTaggedText(sb, theme, parts);
                }
            }

            if (sections.TryGetValue(SymbolDescriptionGroups.AwaitableUsageText, out parts))
            {
                if (!parts.IsDefaultOrEmpty)
                {
                    sb.AppendLine();
                    TaggedTextUtil.AppendTaggedText(sb, theme, parts);
                }
            }


            if (sections.TryGetValue(SymbolDescriptionGroups.Exceptions, out parts))
            {
                if (!parts.IsDefaultOrEmpty)
                {
                    sb.AppendLine();
                    TaggedTextUtil.AppendTaggedText(sb, theme, parts);
                }
            }
            sb.Append("</span>");

            tooltipInfo.SignatureMarkup = sb.ToString();
            return(tooltipInfo);
        }
Пример #52
0
        static void Format(PolicyContainer policyParent, IEnumerable <string> mimeTypeChain, TextEditor editor, DocumentContext context, int startOffset, int endOffset, bool exact, bool formatLastStatementOnly = false, OptionSet optionSet = null)
        {
            TextSpan span;

            if (exact)
            {
                span = new TextSpan(startOffset, endOffset - startOffset);
            }
            else
            {
                span = new TextSpan(0, endOffset);
            }

            var analysisDocument = context.AnalysisDocument;

            if (analysisDocument == null)
            {
                return;
            }
            using (var undo = editor.OpenUndoGroup(/*OperationType.Format*/)) {
                try {
                    var syntaxTree = analysisDocument.GetSyntaxTreeAsync().WaitAndGetResult(default(CancellationToken));
                    var root       = syntaxTree.GetRoot();
                    if (formatLastStatementOnly)
                    {
                        var token  = root.FindToken(endOffset);
                        var tokens = Microsoft.CodeAnalysis.CSharp.Utilities.FormattingRangeHelper.FindAppropriateRange(token);
                        if (tokens.HasValue)
                        {
                            span = new TextSpan(tokens.Value.Item1.SpanStart, editor.CaretOffset - tokens.Value.Item1.SpanStart);
                        }
                        else
                        {
                            var parent = token.Parent;
                            if (parent != null)
                            {
                                span = new TextSpan(parent.FullSpan.Start, editor.CaretOffset - parent.FullSpan.Start);
                            }
                        }
                    }
                    if (optionSet == null)
                    {
                        optionSet = context.GetOptionsAsync().WaitAndGetResult(default(CancellationToken));
                    }
                    var rules   = Formatter.GetDefaultFormattingRules(analysisDocument);
                    var changes = Formatter.GetFormattedTextChanges(root, Roslyn.Utilities.SpecializedCollections.SingletonEnumerable(span), context.RoslynWorkspace, optionSet, rules, default(CancellationToken));
                    editor.ApplyTextChanges(changes.Where(c => {
                        if (!exact)
                        {
                            return(true);
                        }
                        return(span.Contains(c.Span.Start));
                    }));
                } catch (Exception e) {
                    LoggingService.LogError("Error in on the fly formatter", e);
                }
            }
        }
 public TestCompletionWidget(TextEditor editor, DocumentContext document)
 {
     this.editor     = editor;
     documentContext = document;
 }
Пример #54
0
 public static void Format(TextEditor editor, DocumentContext context)
 {
     Format(editor, context, 0, editor.Length);
 }
Пример #55
0
 public override bool IsValidInContext(DocumentContext context)
 {
     //can only attach if there is not already an attached BaseXmlEditorExtension
     return(context.GetContent <BaseXmlEditorExtension> () == null);
 }
        public async static Task <IEnumerable <CodeRefactoringDescriptor> > GetCodeRefactoringsAsync(DocumentContext documentContext, string language, CancellationToken cancellationToken = default(CancellationToken))
        {
            var result = new List <CodeRefactoringDescriptor> ();

            foreach (var provider in providers)
            {
                result.AddRange(await provider.GetCodeRefactoringDescriptorsAsync(documentContext, language, cancellationToken).ConfigureAwait(false));
            }
            return(result);
        }
Пример #57
0
 protected virtual Task CorrectIndentingImplementationAsync(TextEditor editor, DocumentContext context, int startLine, int endLine, CancellationToken cancellationToken)
 {
     for (int i = startLine; i <= endLine; i++)
     {
         CorrectIndentingImplementation(context.Project.Policies, editor, i);
     }
     return(Task.CompletedTask);
 }
        public static async Task <IEnumerable <ValidCodeAction> > GetValidActionsAsync(TextEditor editor, DocumentContext doc, TextSpan span, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (editor == null)
            {
                throw new ArgumentNullException("editor");
            }
            if (doc == null)
            {
                throw new ArgumentNullException("doc");
            }
            var parsedDocument = doc.ParsedDocument;
            var actions        = new List <ValidCodeAction> ();

            if (parsedDocument == null)
            {
                return(actions);
            }
            var model = parsedDocument.GetAst <SemanticModel> ();

            if (model == null)
            {
                return(actions);
            }
            var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);

            if (span.End > root.Span.End)
            {
                return(actions);
            }
            TextSpan tokenSegment = span;
            var      token        = root.FindToken(span.Start);

            if (!token.IsMissing)
            {
                tokenSegment = token.Span;
            }
            try {
                if (codeRefactoringCache == null)
                {
                    codeRefactoringCache = (await GetCodeRefactoringsAsync(doc, MimeTypeToLanguage(editor.MimeType), cancellationToken).ConfigureAwait(false)).ToList();
                }
                foreach (var descriptor in codeRefactoringCache)
                {
                    var analysisDocument = doc.AnalysisDocument;
                    if (cancellationToken.IsCancellationRequested || analysisDocument == null)
                    {
                        return(Enumerable.Empty <ValidCodeAction> ());
                    }
                    try {
                        await descriptor.GetProvider().ComputeRefactoringsAsync(
                            new CodeRefactoringContext(analysisDocument, span, delegate(CodeAction ca) {
                            var nrca         = ca as NRefactoryCodeAction;
                            var validSegment = tokenSegment;
                            if (nrca != null)
                            {
                                validSegment = nrca.TextSpan;
                            }
                            actions.Add(new ValidCodeAction(ca, validSegment));
                        }, cancellationToken)
                            ).ConfigureAwait(false);
                    } catch (OperationCanceledException) {
                        if (cancellationToken.IsCancellationRequested)
                        {
                            return(Enumerable.Empty <ValidCodeAction> ());
                        }
                    } catch (AggregateException) {
                        if (cancellationToken.IsCancellationRequested)
                        {
                            return(Enumerable.Empty <ValidCodeAction> ());
                        }
                    } catch (Exception e) {
                        LoggingService.LogError("Error while getting refactorings from " + descriptor.IdString, e);
                        continue;
                    }
                }
            } catch (OperationCanceledException) {
                if (cancellationToken.IsCancellationRequested)
                {
                    return(Enumerable.Empty <ValidCodeAction> ());
                }
            } catch (AggregateException) {
                if (cancellationToken.IsCancellationRequested)
                {
                    return(Enumerable.Empty <ValidCodeAction> ());
                }
            }
            return(actions);
        }
Пример #59
0
 public AnalysisDocument(TextEditor editor, DocumentContext documentContext)
 {
     this.Editor          = editor;
     this.CaretLocation   = editor.CaretLocation;
     this.DocumentContext = documentContext;
 }
Пример #60
0
 public DocumentQueries(DocumentContext dbContext)
 {
     _dbContext = dbContext;
 }