public static NRefactoryResolver CreateResolverForContext(LanguageProperties language, ITextEditor context) { NRefactoryResolver resolver = new NRefactoryResolver(language); resolver.Initialize(ParserService.GetParseInformation(context.FileName), context.Caret.Line, context.Caret.Column); return(resolver); }
// this should use CodeGenerator and build a BlockStatement to work for both C# and VB string GetSwitchBodyCode(IReturnType enumType, string indent, CodeGenerator generator) { if (generator == null) { return(string.Empty); } ParseInformation parseInfo = ParserService.GetParseInformation(this.Editor.FileName); var visitor = new CSharpOutputVisitor(); CodeGenerator.ConvertType(enumType, this.classFinderContext).AcceptVisitor(visitor, null); var qualifiedEnumType = visitor.Text; StringBuilder sb = new StringBuilder(); bool first = true; foreach (var enumCase in GetEnumCases(enumType)) { string qualifiedName = qualifiedEnumType + "." + enumCase.Name; sb.AppendLine(string.Format((first ? "" : indent) + "case {0}:", qualifiedName)); sb.AppendLine(indent + context.Tab); sb.AppendLine(indent + context.Tab + "break;"); first = false; } sb.AppendLine(indent + "default:"); sb.Append(string.Format(indent + context.Tab + "throw new Exception(\"Invalid value for {0}\");", enumType.Name)); return(sb.ToString()); }
void ShowDotCompletion(string currentText) { StackFrame frame = this.process.GetCurrentExecutingFrame(); if (frame == null) { return; } var seg = frame.NextStatement; if (seg == null) { return; } var expressionFinder = ParserService.GetExpressionFinder(seg.Filename); var info = ParserService.GetParseInformation(seg.Filename); string text = ParserService.GetParseableFileContent(seg.Filename).Text; int currentOffset = TextEditor.Caret.Offset - console.CommandOffset - 1; var expr = expressionFinder.FindExpression(currentText, currentOffset); expr.Region = new DomRegion(seg.StartLine, seg.StartColumn, seg.EndLine, seg.EndColumn); var rr = resolver.Resolve(expr, info, text); if (rr != null) { TextEditor.ShowCompletionWindow(new DotCodeCompletionItemProvider().GenerateCompletionListForResolveResult(rr, expr.Context)); } }
public override ICompletionItemList GenerateCompletionList(ITextEditor editor) { ParseInformation parseInfo = ParserService.GetParseInformation(editor.FileName); if (parseInfo == null) { return(null); } IClass c = parseInfo.CompilationUnit.GetInnermostClass(editor.Caret.Line, editor.Caret.Column); if (c == null) { return(null); } LanguageProperties language = c.ProjectContent.Language; OverrideCompletionItemList result = new OverrideCompletionItemList(); foreach (IMember m in GetOverridableMembers(c)) { if (language.ShowMemberInOverrideCompletion(m)) { result.Items.Add(new OverrideCompletionItem(m)); } } result.SortItems(); return(result); }
Variable ResolveVariable(Variable variable) { Dom.ParseInformation info = ParserService.GetParseInformation(this.textEditor.FileName); Dom.ExpressionResult res = new Dom.ExpressionResult(variable.Name, Dom.DomRegion.FromLocation(variable.StartPos, variable.EndPos), Dom.ExpressionContext.Default, null); Dom.ResolveResult result = this.GetResolver().Resolve(res, info, this.textEditor.Document.Text); Dom.IReturnType type = currentProjectContent.SystemTypes.Object; Dom.ClassFinder finder = new Dom.ClassFinder(currentClass, textEditor.Caret.Line, textEditor.Caret.Column); if (result != null && result.ResolvedType != null) { type = result.ResolvedType; } if (variable.Type.Type == "var") { variable.Type = Dom.Refactoring.CodeGenerator.ConvertType(type, finder); } variable.IsReferenceType = type.IsReferenceType == true; return(variable); }
public override void Run() { IViewContent content = WorkbenchSingleton.Workbench.ActiveViewContent; if (content != null && content.PrimaryFileName != null && content is IEditable) { IParser p = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(((IEditable)content).Text)); p.Parse(); if (p.Errors.Count > 0) { MessageService.ShowError("${res:ICSharpCode.SharpDevelop.Commands.Convert.CorrectSourceCodeErrors}\n" + p.Errors.ErrorOutput); return; } ICSharpCode.NRefactory.PrettyPrinter.CSharpOutputVisitor output = new ICSharpCode.NRefactory.PrettyPrinter.CSharpOutputVisitor(); List <ISpecial> specials = p.Lexer.SpecialTracker.CurrentSpecials; PreprocessingDirective.VBToCSharp(specials); IAstVisitor v = new VBNetToCSharpConvertVisitor(ParserService.CurrentProjectContent, ParserService.GetParseInformation(content.PrimaryFileName)); v.VisitCompilationUnit(p.CompilationUnit, null); using (SpecialNodesInserter.Install(specials, output)) { output.VisitCompilationUnit(p.CompilationUnit, null); } FileService.NewFile("Generated.cs", output.Text); } }
public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped) { ParseInformation parseInfo = ParserService.GetParseInformation(fileName); if (parseInfo == null) { return(null); } IClass c = parseInfo.MostRecentCompilationUnit.GetInnermostClass(textArea.Caret.Line, textArea.Caret.Column); if (c == null) { return(null); } List <ICompletionData> result = new List <ICompletionData>(); foreach (IMethod m in GetOverridableMethods(c)) { result.Add(new OverrideCompletionData(m)); } foreach (IProperty p in GetOverridableProperties(c)) { result.Add(new OverrideCompletionData(p)); } return(result.ToArray()); }
void AddTopLevelItems(List <object> resultItems, ITextEditor textEditor, ExpressionResult expressionResult, List <string> definitions, bool addAsSubmenu) { // Insert items at this position to get the outermost expression first, followed by the inner expressions (if any). int insertIndex = resultItems.Count; ResolveResult rr = ResolveExpressionAtCaret(textEditor, expressionResult); MenuItem item = null; if (rr is MethodGroupResolveResult) { item = MakeItem(definitions, ((MethodGroupResolveResult)rr).GetMethodIfSingleOverload()); } else if (rr is MemberResolveResult) { MemberResolveResult mrr = (MemberResolveResult)rr; item = MakeItem(definitions, mrr.ResolvedMember); // Seems not to be needed, as AddItemForCurrentClassAndMethod works for indexer as well (martinkonicek) /*if (RefactoringService.FixIndexerExpression(expressionFinder, ref expressionResult, mrr)) { * if (item != null) { * // Insert this member * resultItems.Insert(insertIndex, item); * } * // Include menu for the underlying expression of the * // indexer expression as well. * AddTopLevelItems(textEditor, expressionResult, true); * }*/ } else if (rr is TypeResolveResult) { item = MakeItem(definitions, ((TypeResolveResult)rr).ResolvedClass); } else if (rr is LocalResolveResult) { bool isDefinition = textEditor.Caret.Line == ((LocalResolveResult)rr).VariableDefinitionRegion.BeginLine; ParseInformation pi = ParserService.GetParseInformation(textEditor.FileName); IProjectContent pc = null; if (pi != null) { pc = pi.CompilationUnit.ProjectContent; } RefactoringMenuContext context = new RefactoringMenuContext(textEditor, expressionResult, rr, isDefinition, pc, pi.CompilationUnit); item = MakeItem((LocalResolveResult)rr, context); insertIndex = 0; // Insert local variable menu item at the topmost position. } if (item != null) { if (addAsSubmenu) { resultItems.Insert(insertIndex, item); } else { foreach (object subItem in item.Items) { resultItems.Add(subItem); } item.Items.Clear(); // detach resultItems from old parent } } }
protected virtual void OKButtonClick(object sender, RoutedEventArgs e) { ParseInformation parseInfo = ParserService.GetParseInformation(editor.FileName); if (optionBindings != null) { foreach (OptionBinding binding in optionBindings) { binding.Save(); } } if (parseInfo != null) { LanguageProperties language = parseInfo.CompilationUnit.Language; IClass current = parseInfo.CompilationUnit.GetInnermostClass(anchor.Line, anchor.Column); using (editor.Document.OpenUndoGroup()) { // GenerateCode could modify the document. // So read anchor.Offset after code generation. string code = GenerateCode(language, current) ?? ""; editor.Document.Insert(anchor.Offset, code); } } Deactivate(); }
static bool TryDeclarationTypeInference(ITextEditor editor, IDocumentLine curLine) { string lineText = editor.Document.GetText(curLine.Offset, curLine.Length); ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new System.IO.StringReader(lineText)); if (lexer.NextToken().Kind != Tokens.Dim) { return(false); } if (lexer.NextToken().Kind != Tokens.Identifier) { return(false); } if (lexer.NextToken().Kind != Tokens.As) { return(false); } Token t1 = lexer.NextToken(); if (t1.Kind != Tokens.QuestionMark) { return(false); } Token t2 = lexer.NextToken(); if (t2.Kind != Tokens.Assign) { return(false); } string expr = lineText.Substring(t2.Location.Column); LoggingService.Debug("DeclarationTypeInference: >" + expr + "<"); ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr), editor.Caret.Line, t2.Location.Column, editor.FileName, editor.Document.Text); if (rr != null && rr.ResolvedType != null) { ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.Caret.Line, t1.Location.Column); VBNetAmbience ambience = new VBNetAmbience(); if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context)) { ambience.ConversionFlags = ConversionFlags.None; } else { ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames; } string typeName = ambience.Convert(rr.ResolvedType); using (editor.Document.OpenUndoGroup()) { int offset = curLine.Offset + t1.Location.Column - 1; editor.Document.Remove(offset, 1); editor.Document.Insert(offset, typeName); } editor.Caret.Column += typeName.Length - 1; return(true); } return(false); }
public override bool InsertAction(TextArea textArea, char ch) { ClassFinder context = new ClassFinder(ParserService.GetParseInformation(textArea.MotherTextEditorControl.FileName), textArea.Caret.Line + 1, textArea.Caret.Column + 1); int caretPosition = textArea.Caret.Offset; LineSegment line = textArea.Document.GetLineSegment(textArea.Caret.Line); string lineText = textArea.Document.GetText(line.Offset, caretPosition - line.Offset); foreach (char c in lineText) { if (!char.IsWhiteSpace(c) && !char.IsLetterOrDigit(c)) { return(base.InsertAction(textArea, ch)); } } string indentation = lineText.Substring(0, lineText.Length - lineText.TrimStart().Length); CodeGenerator codeGen = ParserService.CurrentProjectContent.Language.CodeGenerator; string text = codeGen.GenerateCode(codeGen.GetOverridingMethod(member, context), indentation); text = text.TrimEnd(); // remove newline from end textArea.Document.Replace(line.Offset, caretPosition - line.Offset, text); int endPos = line.Offset + text.Length; int endLine = textArea.Document.GetLineNumberForOffset(endPos); line = textArea.Document.GetLineSegment(endLine); textArea.MotherTextAreaControl.JumpTo(endLine, endPos - line.Offset); textArea.Refresh(); return(true); }
public IReturnType GetTypeOfExpression(AST.Expression expr, IClass callingClass) { AST.Node node = expr; AST.LexicalInfo lexInfo; do { if (node == null) { return(null); } lexInfo = node.LexicalInfo; node = node.ParentNode; } while (lexInfo == null || lexInfo.FileName == null); if (!Initialize(ParserService.GetParseInformation(lexInfo.FileName), lexInfo.Line, lexInfo.Column)) { return(null); } if (callingClass != null) { this.callingClass = callingClass; } ResolveVisitor visitor = new ResolveVisitor(this); visitor.Visit(expr); if (visitor.ResolveResult == null) { return(null); } else { return(visitor.ResolveResult.ResolvedType); } }
protected Dom.IMember GetParentMember(ICSharpCode.TextEditor.TextEditorControl textEditor, int line, int column) { Dom.ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName); if (parseInfo != null) { Dom.IClass c = parseInfo.MostRecentCompilationUnit.GetInnermostClass(line, column); if (c != null) { foreach (Dom.IMember member in c.Properties) { if (member.BodyRegion.IsInside(line, column)) { return(member); } } foreach (Dom.IMember member in c.Methods) { if (member.BodyRegion.IsInside(line, column)) { return(member); } } } } return(null); }
void CaretPositionChanged(object sender, EventArgs e) { // ignore simple movements if (e != EventArgs.Empty) { return; } try { ParseInformation parseInfo = ParserService.GetParseInformation(textAreaControl.FileName); if (parseInfo != null) { if (currentCompilationUnit != (ICompilationUnit)parseInfo.MostRecentCompilationUnit) { currentCompilationUnit = (ICompilationUnit)parseInfo.MostRecentCompilationUnit; if (currentCompilationUnit != null) { FillClassComboBox(true); FillMembersComboBox(); } } UpdateClassComboBox(); UpdateMembersComboBox(); } } catch (Exception ex) { MessageService.ShowError(ex); } }
bool DoCaseCompletion(ITextEditor editor) { ITextEditorCaret caret = editor.Caret; NRefactoryResolver r = new NRefactoryResolver(LanguageProperties.CSharp); if (r.Initialize(ParserService.GetParseInformation(editor.FileName), caret.Line, caret.Column)) { INode currentMember = r.ParseCurrentMember(editor.Document.Text); if (currentMember != null) { CaseCompletionSwitchFinder ccsf = new CaseCompletionSwitchFinder(caret.Line, caret.Column); currentMember.AcceptVisitor(ccsf, null); if (ccsf.bestStatement != null) { r.RunLookupTableVisitor(currentMember); ResolveResult rr = r.ResolveInternal(ccsf.bestStatement.SwitchExpression, ExpressionContext.Default); if (rr != null && rr.ResolvedType != null) { return(ProvideContextCompletion(editor, rr.ResolvedType, ' ')); } } } } return(false); }
public override ResolveResult Resolve(ITextEditor editor, ExpressionResult expressionResult) { // bypass ParserService.Resolve and set resolver.LimitMethodExtractionUntilCaretLine ParseInformation parseInfo = ParserService.GetParseInformation(editor.FileName); NRefactoryResolver resolver = new NRefactoryResolver(LanguageProperties.CSharp); resolver.LimitMethodExtractionUntilLine = editor.Caret.Line; return(resolver.Resolve(expressionResult, parseInfo, editor.Document.Text)); }
protected override List <ICompletionEntry> CtrlSpace(ITextEditor editor, ExpressionContext context) { return(new BooResolver().CtrlSpace( editor.Caret.Line, editor.Caret.Column, ParserService.GetParseInformation(editor.FileName), editor.Document.Text, context)); }
protected override ResolveResult Resolve(ExpressionResult expressionResult, int caretLineNumber, int caretColumn, string fileName, string fileContent) { // bypass ParserService.Resolve and set resolver.LimitMethodExtractionUntilCaretLine ParseInformation parseInfo = ParserService.GetParseInformation(fileName); NRefactoryResolver resolver = new NRefactoryResolver(LanguageProperties.CSharp); resolver.LimitMethodExtractionUntilLine = caretLineNumber; return(resolver.Resolve(expressionResult, parseInfo, fileContent)); }
CodeGenerator GetCodeGenerator(EditorContext context) { var parseInfo = ParserService.GetParseInformation(context.Editor.FileName); if (parseInfo == null) { return(null); } return(parseInfo.CompilationUnit.Language.CodeGenerator); }
protected override List <ICompletionEntry> CtrlSpace(ITextEditor editor, ExpressionContext context) { var resolver = new Dom.NRefactoryResolver.NRefactoryResolver(language); return(resolver.CtrlSpace( editor.Caret.Line, editor.Caret.Column, ParserService.GetParseInformation(editor.FileName), editor.Document.Text, context, this.ShowItemsFromAllNamespaces)); }
/// <summary> /// Returns CodeGenerator for C# or VB depending on the current file where snippet is being inserted. /// </summary> CodeGenerator GetCodeGeneratorForCurrentFile() { ParseInformation parseInfo = ParserService.GetParseInformation(this.Editor.FileName); if (parseInfo != null) { return(parseInfo.CompilationUnit.Language.CodeGenerator); } return(null); }
protected Dom.IMember GetParentMember(ITextEditor textEditor, int line, int column) { Dom.ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName); if (parseInfo != null) { return(parseInfo.CompilationUnit.GetInnermostMember(line, column)); } return(null); }
IProjectContent GetProjectContentForFile() { ParseInformation parseInfo = ParserService.GetParseInformation(this.DesignerCodeFile.FileName); if (parseInfo != null) { return(parseInfo.CompilationUnit.ProjectContent); } return(DefaultProjectContent.DummyProjectContent); }
InsertCtorDialog CreateDialog(InsertionContext context) { ITextEditor textEditor = context.TextArea.GetService(typeof(ITextEditor)) as ITextEditor; if (textEditor == null) { return(null); } IEditorUIService uiService = textEditor.GetService(typeof(IEditorUIService)) as IEditorUIService; if (uiService == null) { return(null); } ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName); if (parseInfo == null) { return(null); } CodeGenerator generator = parseInfo.CompilationUnit.Language.CodeGenerator; // cannot use insertion position at this point, because it might not be // valid, because we are still generating the elements. // DOM is not updated ICSharpCode.AvalonEdit.Document.TextLocation loc = context.Document.GetLocation(context.StartPosition); IClass current = parseInfo.CompilationUnit.GetInnermostClass(loc.Line, loc.Column); if (current == null) { return(null); } List <PropertyOrFieldWrapper> parameters = CreateCtorParams(current).ToList(); if (!parameters.Any()) { return(null); } ITextAnchor anchor = textEditor.Document.CreateAnchor(context.InsertionPosition); anchor.MovementType = AnchorMovementType.BeforeInsertion; InsertCtorDialog dialog = new InsertCtorDialog(context, textEditor, anchor, current, parameters); dialog.Element = uiService.CreateInlineUIElement(anchor, dialog); return(dialog); }
void UpdateClassComboBox() { // Still needed ? if (currentCompilationUnit == null) { currentCompilationUnit = (ICompilationUnit)ParserService.GetParseInformation(FileUtility.NormalizePath(textAreaControl.FileName)).MostRecentCompilationUnit; } autoselect = false; try { if (currentCompilationUnit != null) { //// Alex: when changing between files in different compilation units whole process must be restarted //// happens usually when files are opened from different project(s) for (int i = 0; i < classComboBox.Items.Count; ++i) { if (((ComboBoxItem)classComboBox.Items[i]).IsInside(textAreaControl.ActiveTextAreaControl.Caret.Line)) { bool innerClassContainsCaret = false; for (int j = i + 1; j < classComboBox.Items.Count; ++j) { if (((ComboBoxItem)classComboBox.Items[j]).IsInside(textAreaControl.ActiveTextAreaControl.Caret.Line)) { innerClassContainsCaret = true; break; } } if (!innerClassContainsCaret) { if (classComboBox.SelectedIndex != i) { classComboBox.SelectedIndex = i; FillMembersComboBox(); } if (!classComboBoxSelectedMember) { classComboBox.Refresh(); } classComboBoxSelectedMember = true; return; } } } } if (classComboBoxSelectedMember) { classComboBox.Refresh(); classComboBoxSelectedMember = false; } } finally { autoselect = true; } // classComboBox.SelectedIndex = -1; }
ResolveResult Resolve(string prog, ExpressionResult er, string marker) { Register(prog); int line, column; GetPos(prog, marker, out line, out column); er.Region = new DomRegion(line, column); BooResolver r = new BooResolver(); return(r.Resolve(er, ParserService.GetParseInformation(fileName), prog)); }
static ResolveResult ResolveExpressionAtCaret(ITextEditor textArea, ExpressionResult expressionResult) { if (expressionResult.Expression != null) { if (expressionResult.Region.IsEmpty) { expressionResult.Region = new DomRegion(textArea.Caret.Line, textArea.Caret.Column); } return(resolver.Resolve(expressionResult, ParserService.GetParseInformation(textArea.FileName), textArea.Document.Text)); } return(null); }
public bool InsightRefreshOnComma(ITextEditor editor, char ch, out IInsightWindow insightWindow) { // Show MethodInsightWindow or IndexerInsightWindow NRefactoryResolver r = new NRefactoryResolver(languageProperties); Location cursorLocation = editor.Caret.Position; if (r.Initialize(ParserService.GetParseInformation(editor.FileName), 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; 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 { LookupOffset = offset }; var insightItems = insightProvider.ProvideInsight(editor); insightWindow = ShowInsight(editor, insightItems, ResolveCallParameters(editor, call), ch); return(insightWindow != null); } else { Core.LoggingService.Warn("Expected '(' or '[' at start position"); } } } } insightWindow = null; return(false); }
ExpressionContext FindExactContextForNewCompletion(SharpDevelopTextAreaControl editor, string documentToCursor, LineSegment currentLine, int pos) { CSharpExpressionFinder ef = CreateExpressionFinder(editor.FileName); // 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.FileName, editor.Text); 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.FileName), editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1) ), ""); if (suggestedClassName != c.Name) { // create an IClass instance that includes the type arguments in its name context.SuggestedItem = new RenamedClass(c, suggestedClassName); } else { context.SuggestedItem = c; } } return(context); } } return(null); }
static IClass GetCurrentClass(ITextEditor editor) { var caret = editor.Caret; NRefactoryResolver r = new NRefactoryResolver(LanguageProperties.VBNet); if (r.Initialize(ParserService.GetParseInformation(editor.FileName), caret.Line, caret.Column)) { return(r.CallingClass); } else { return(null); } }