private object GetParameter() { var expressionFinder = new CSharpExpressionFinder(ParserService.GetParseInformation(AssociatedObject.Text, ProjectContent)); var caret = AssociatedObject.TextArea.Caret; var result = expressionFinder.FindFullExpression(AssociatedObject.Text, caret.Offset); var resolveResult = ParserService.Resolve(result, caret.Line, caret.Column, AssociatedObject.Text, ProjectContent); if (resolveResult == null || !resolveResult.IsValid) { return(null); } if (resolveResult is MemberResolveResult) { return(((MemberResolveResult)resolveResult).ResolvedMember); } if (resolveResult is TypeResolveResult) { return(((TypeResolveResult)resolveResult).ResolvedClass); } if (resolveResult is NamespaceResolveResult) { return(new NamespaceEntry(((NamespaceResolveResult)resolveResult).Name)); } return(null); }
protected IMember GetCurrentMember(ITextEditor editor) { var caret = editor.Caret; var r = new NRefactoryResolver(_languageProperties); var parseInformation = ParserService.GetParseInformation(editor.Document.Text, ProjectContent); return(r.Initialize(parseInformation, caret.Line, caret.Column) ? r.CallingMember : null); }
public override ResolveResult Resolve(ITextEditor editor, ExpressionResult expressionResult) { // bypass ParserService.Resolve and set resolver.LimitMethodExtractionUntilCaretLine ParseInformation parseInfo = ParserService.GetParseInformation(editor.Document.Text, ProjectContent); var resolver = new NRefactoryResolver(LanguageProperties.CSharp) { LimitMethodExtractionUntilLine = editor.Caret.Line }; return(resolver.Resolve(expressionResult, parseInfo, editor.Document.Text)); }
ExpressionContext FindExactContextForNewCompletion(ITextEditor editor, string documentToCursor, IDocumentLine currentLine, int pos) { CSharpExpressionFinder ef = CreateExpressionFinder(editor.Document.Text); // find expression on left hand side of the assignment ExpressionResult lhsExpr = ef.FindExpression(documentToCursor, currentLine.Offset + pos); if (lhsExpr.Expression != null) { ResolveResult rr = ParserService.Resolve(lhsExpr, currentLine.LineNumber, pos, editor.Document.Text, editor.Document.Text, ProjectContent); if (rr != null && rr.ResolvedType != null) { ExpressionContext context; IClass c; if (rr.ResolvedType.IsArrayReturnType) { // when creating an array, all classes deriving from the array's element type are allowed IReturnType elementType = rr.ResolvedType.CastToArrayReturnType().ArrayElementType; c = elementType != null?elementType.GetUnderlyingClass() : null; context = ExpressionContext.TypeDerivingFrom(elementType, false); } else { // when creating a normal instance, all non-abstract classes deriving from the type // are allowed c = rr.ResolvedType.GetUnderlyingClass(); context = ExpressionContext.TypeDerivingFrom(rr.ResolvedType, true); } if (c != null && context.ShowEntry(c)) { // Try to suggest an entry (List<int> a = new => suggest List<int>). string suggestedClassName = LanguageProperties.CSharp.CodeGenerator.GenerateCode( CodeGenerator.ConvertType( rr.ResolvedType, new ClassFinder(ParserService.GetParseInformation(editor.Document.Text, ProjectContent), editor.Caret.Line, editor.Caret.Column) ), ""); context.SuggestedItem = suggestedClassName != c.Name ? new SuggestedCodeCompletionItem(c, suggestedClassName, ProjectContent) : new CodeCompletionItem(c, ProjectContent); } return(context); } } return(null); }
public override bool HandleKeyword(ITextEditor editor, string word) { switch (word) { case "using": if (IsInComment(editor)) { return(false); } ParseInformation parseInfo = ParserService.GetParseInformation(editor.Document.Text, ProjectContent); if (parseInfo != null) { IClass innerMostClass = parseInfo.CompilationUnit.GetInnermostClass(editor.Caret.Line, editor.Caret.Column); if (innerMostClass == null) { ShowCompletion(CompletionItemProviderFactory.Create(LanguageProperties.CSharp, ExpressionContext.Namespace, ProjectContent), editor, ProjectContent); return(true); } } break; case "as": case "is": if (IsInComment(editor)) { return(false); } ShowCompletion(CompletionItemProviderFactory.Create(LanguageProperties.CSharp, ExpressionContext.Type, ProjectContent), editor, ProjectContent); return(true); case "override": if (IsInComment(editor)) { return(false); } ShowCompletion(new OverrideCompletionItemProvider(ProjectContent), editor, ProjectContent); return(true); case "new": return(ShowNewCompletion(editor)); case "case": if (IsInComment(editor)) { return(false); } return(DoCaseCompletion(editor)); case "return": if (IsInComment(editor)) { return(false); } IMember m = GetCurrentMember(editor); if (m != null) { return(ProvideContextCompletion(editor, m.ReturnType, ' ')); } break; } return(false); }
CSharpExpressionFinder CreateExpressionFinder(string fileName) { return(new CSharpExpressionFinder(ParserService.GetParseInformation(fileName, ProjectContent))); }
public bool InsightRefreshOnComma(ITextEditor editor, char ch, out IInsightWindow insightWindow, IProjectContent projectContent) { // Show MethodInsightWindow or IndexerInsightWindow NRefactoryResolver r = new NRefactoryResolver(languageProperties); Location cursorLocation = editor.Caret.Position; if (r.Initialize(ParserService.GetParseInformation(editor.Document.Text, projectContent), cursorLocation.Y, cursorLocation.X)) { TextReader currentMethod = r.ExtractCurrentMethod(editor.Document.Text); if (currentMethod != null) { ILexer lexer = ParserFactory.CreateLexer(language, currentMethod); Token token; InspectedCall call = new InspectedCall(Location.Empty, null); call.parent = call; // HACK MINI PARSER // The following code tries to find the current nested call until the caret position (= cursorLocation) is // reached. call.commas contains all commas up to the caret position. // DOES NOT HANDLE GENERICS CORRECTLY! This is sufficient for overload "search", because if we miss one // overload it does not matter. But if we highlight the wrong parameter (see below) it DOES MATTER! while ((token = lexer.NextToken()) != null && token.Kind != eofToken && token.Location < cursorLocation) { if (token.Kind == commaToken) { call.commas.Add(token.Location); } else if (token.Kind == openParensToken || token.Kind == openBracketToken || token.Kind == openBracesToken) { call = new InspectedCall(token.Location, call); } else if (token.Kind == closeParensToken || token.Kind == closeBracketToken || token.Kind == closeBracesToken) { call = call.parent; } } int offset = LocationToOffset(editor, call.start); if (offset >= 0 && offset < editor.Document.TextLength) { char c = editor.Document.GetCharAt(offset); if (c == '(' || c == '[') { var insightProvider = new MethodInsightProvider(projectContent) { LookupOffset = offset }; var insightItems = insightProvider.ProvideInsight(editor); // find highlighted parameter // see mini parser description above; the number of recognized parameters is the index // of the current parameter! var parameters = ResolveCallParameters(editor, call); highlightedParameter = parameters.Count; insightWindow = ShowInsight(editor, insightItems, parameters, ch); return(insightWindow != null); } else { } } } } insightWindow = null; return(false); }