public WatchInputBox(string text, string caption) : base()
{
InitializeComponent();
// UI
text = StringParser.Parse(text);
this.Title = StringParser.Parse(caption);
this.ConsolePanel.Content = console;
if (ProjectService.CurrentProject == null) return;
// get language
language = ProjectService.CurrentProject.Language;
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language));
// FIXME set language
if (language == "VB" || language == "VBNet") {
console.SetHighlighting("VBNET");
}
else {
console.SetHighlighting("C#");
}
// get process
WindowsDebugger debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
debugger.ProcessSelected += delegate(object sender, ProcessEventArgs e) {
this.Process = e.Process;
};
this.Process = debugger.DebuggedProcess;
}
public FindMemberAstVisitor(NRefactoryResolver resolver, IEditableTextFile file, MonoDevelop.Projects.Dom.INode searchedMember)
{
fileName = file.Name;
text = new Mono.TextEditor.Document();
text.Text = file.Text;
Init(resolver, searchedMember);
}
public NRefactoryParameterDataProvider(TextEditorData editor, NRefactoryResolver resolver, MethodResolveResult resolveResult)
{
this.staticResolve = resolveResult.StaticResolve;
bool includeProtected = true;
HashSet <string> alreadyAdded = new HashSet <string> ();
foreach (IMethod method in resolveResult.Methods)
{
if (method.IsConstructor)
{
continue;
}
string str = ambience.GetString(method, OutputFlags.IncludeParameters | OutputFlags.GeneralizeGenerics | OutputFlags.IncludeGenerics);
if (alreadyAdded.Contains(str))
{
continue;
}
alreadyAdded.Add(str);
if (method.IsAccessibleFrom(resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected))
{
methods.Add(method);
}
}
methods.Sort(MethodComparer);
}
public override IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, IEnumerable<INode> searchedMembers)
{
HashSet<int > positions = new HashSet<int> ();
var editor = TextFileProvider.Instance.GetTextEditorData (fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document);
visitor.IncludeXmlDocumentation = IncludeDocumentation;
visitor.Init (searchedMembers);
if (!visitor.FileContainsMemberName ()) {
yield break;
}
var doc = ProjectDomService.ParseFile (dom, fileName, () => editor.Text);
if (doc == null || doc.CompilationUnit == null)
yield break;
var resolver = new NRefactoryResolver (dom, doc.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
visitor.ParseFile (resolver);
visitor.RunVisitor (resolver);
foreach (var reference in visitor.FoundReferences) {
if (positions.Contains (reference.Position))
continue;
positions.Add (reference.Position);
yield return reference;
}
visitor.ClearParsers ();
}
private void OnToolTipRequest(object sender, ToolTipRequestEventArgs e)
{
if (e.InDocument && !e.ToolTipShown)
{
IExpressionFinder expressionFinder;
if (MainForm.IsVisualBasic)
{
expressionFinder = new VBExpressionFinder();
}
else
{
expressionFinder = new CSharpExpressionFinder(mainForm.parseInformation);
}
ExpressionResult expression = expressionFinder.FindFullExpression(
editor.Text,
editor.Document.PositionToOffset(e.LogicalPosition));
if (expression.Region.IsEmpty)
{
expression.Region = new DomRegion(e.LogicalPosition.Line + 1, e.LogicalPosition.Column + 1);
}
TextArea textArea = editor.ActiveTextAreaControl.TextArea;
NRefactoryResolver resolver = new NRefactoryResolver(mainForm.myProjectContent.Language);
ResolveResult rr = resolver.Resolve(expression,
mainForm.parseInformation,
textArea.MotherTextEditorControl.Text);
string toolTipText = GetText(rr);
if (toolTipText != null)
{
e.ShowToolTip(toolTipText);
}
}
}
public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
{
var resultList = new List <ICompletionData>();
var document = FEditor.TextDocument as CSDocument;
var parseInfo = document.ParseInfo;
var finder = document.ExpressionFinder;
var text = textArea.Document.GetText(0, textArea.Caret.Offset);
var expressionResult = finder.FindExpression(text, textArea.Caret.Offset);
if (expressionResult.Region.IsEmpty)
{
expressionResult.Region = new Dom.DomRegion(textArea.Caret.Line + 1, textArea.Caret.Column + 1);
}
var resolver = new NRefactoryResolver(LanguageProperties.CSharp);
Debug.WriteLine(string.Format("Generating C# CTRL space completion data for expression result {0}", expressionResult));
PreSelection = string.Empty;
var completionData = resolver.CtrlSpace(textArea.Caret.Line + 1,
textArea.Caret.Column + 1,
parseInfo,
textArea.Document.TextContent,
expressionResult.Context);
if (completionData != null)
{
AddCompletionData(ref resultList, completionData, expressionResult.Context);
}
return(resultList.ToArray());
}
private void OnToolTipRequest(object sender, ToolTipRequestEventArgs e)
{
if (e.InDocument && !e.ToolTipShown)
{
IExpressionFinder expressionFinder;
if (MainForm.IsVisualBasic)
{
expressionFinder = new VBExpressionFinder();
}
else
{
expressionFinder = new CSharpExpressionFinder(mainForm.parseInformation);
}
ExpressionResult expression = expressionFinder.FindFullExpression(
editor.Text,
editor.Document.PositionToOffset(e.LogicalPosition));
if (expression.Region.IsEmpty)
{
expression.Region = new DomRegion(e.LogicalPosition.Line + 1, e.LogicalPosition.Column + 1);
}
TextArea textArea = editor.ActiveTextAreaControl.TextArea;
NRefactoryResolver resolver = new NRefactoryResolver(mainForm.myProjectContent.Language);
ResolveResult rr = resolver.Resolve(expression,
mainForm.parseInformation,
textArea.MotherTextEditorControl.Text);
string toolTipText = GetText(rr);
if (toolTipText != null)
{
e.ShowToolTip(toolTipText);
}
}
}
public ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
{
// We can return code-completion items like this:
// return new ICompletionData[] {
// new DefaultCompletionData("Text", "Description", 1)
// };
NRefactoryResolver resolver = new NRefactoryResolver(mainForm.myProjectContent);
Dom.ResolveResult rr = resolver.Resolve(FindExpression(textArea),
textArea.Caret.Line,
textArea.Caret.Column,
fileName,
textArea.MotherTextEditorControl.Text);
List<ICompletionData> resultList = new List<ICompletionData>();
if (rr != null) {
ArrayList completionData = rr.GetCompletionData(mainForm.myProjectContent);
if (completionData != null) {
AddCompletionData(resultList, completionData);
}
}
//textArea.MotherTextEditorControl.Text = backup;
return resultList.ToArray();
}
bool DoCaseCompletion(ITextEditor editor)
{
ITextEditorCaret caret = editor.Caret;
var r = new NRefactoryResolver(LanguageProperties.CSharp);
if (r.Initialize(ParserService.GetParseInformation(editor.Document.Text, ProjectContent), caret.Line, caret.Column))
{
NRefactory.Ast.INode currentMember = r.ParseCurrentMember(editor.Document.Text);
if (currentMember != null)
{
var 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 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);
}
public WatchInputBox(string text, string caption) : base()
{
InitializeComponent();
// UI
text = StringParser.Parse(text);
this.Title = StringParser.Parse(caption);
this.ConsolePanel.Content = console;
if (ProjectService.CurrentProject == null)
{
language = GetLanguageFromActiveViewContent();
}
else
{
language = GetLanguage(ProjectService.CurrentProject.Language);
}
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language.ToString()));
switch (language)
{
case SupportedLanguage.CSharp:
console.SetHighlighting("C#");
break;
case SupportedLanguage.VBNet:
console.SetHighlighting("VBNET");
break;
}
// get process
this.Process = ((WindowsDebugger)DebuggerService.CurrentDebugger).DebuggedProcess;
}
public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver)
{
return(CreateReturnType(reference,
resolver.CallingClass, resolver.CallingMember,
resolver.CaretLine, resolver.CaretColumn,
resolver.ProjectContent, ReturnTypeOptions.None));
}
private bool DoCaseCompletion(CodeEditorControl editor)
{
Caret caret = editor.ActiveViewControl.Caret;
NRefactoryResolver r = new NRefactoryResolver(ScriptControl.Parser.ProjectParser.CurrentProjectContent, LanguageProperties.CSharp);
if (r.Initialize(editor.ActiveViewControl.FileName, caret.Position.Y + 1, caret.Position.X + 1))
{
AST.INode currentMember = r.ParseCurrentMember(ScriptControl.Parser.ProjectParser.GetFileContents(editor.FileName));
if (currentMember != null)
{
CaseCompletionSwitchFinder ccsf = new CaseCompletionSwitchFinder(caret.Position.Y + 1, caret.Position.X + 1);
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 void ParseFile(NRefactoryResolver resolver)
{
string parseText = text.Text;
ClearParsers();
var parser = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.CSharp, new StringReader(parseText));
parser.Lexer.EvaluateConditionalCompilation = true;
// Console.WriteLine ("parse :" + text.FileName);
parser.Parse();
resolver.SetupParsedCompilationUnit(parser.CompilationUnit);
this.parsers.Add(parser);
List <HashSet <string> > usedIdentifiers = GetUsedDefineCombinations(parser);
for (int i = 0; i < usedIdentifiers.Count; i++)
{
parser.Lexer.ConditionalCompilationSymbols.Clear();
foreach (string define in usedIdentifiers[i])
{
parser.Lexer.ConditionalCompilationSymbols.Add(define, true);
}
parser = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.CSharp, new StringReader(parseText));
parser.Parse();
this.parsers.Add(parser);
}
}
public WatchInputBox(string text, string caption) : base()
{
InitializeComponent();
// UI
text = StringParser.Parse(text);
this.Title = StringParser.Parse(caption);
this.ConsolePanel.Content = console;
if (ProjectService.CurrentProject == null)
language = GetLanguageFromActiveViewContent();
else
language = GetLanguage(ProjectService.CurrentProject.Language);
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language.ToString()));
switch (language) {
case SupportedLanguage.CSharp:
console.SetHighlighting("C#");
break;
case SupportedLanguage.VBNet:
console.SetHighlighting("VBNET");
break;
}
// get process
this.Process = ((WindowsDebugger)DebuggerService.CurrentDebugger).DebuggedProcess;
}
bool DoCaseCompletion(SharpDevelopTextAreaControl editor)
{
ICSharpCode.TextEditor.Caret caret = editor.ActiveTextAreaControl.Caret;
NRefactoryResolver r = new NRefactoryResolver(LanguageProperties.CSharp);
if (r.Initialize(ParserService.GetParseInformation(editor.FileName), caret.Line + 1, caret.Column + 1))
{
AST.INode currentMember = r.ParseCurrentMember(editor.Text);
if (currentMember != null)
{
CaseCompletionSwitchFinder ccsf = new CaseCompletionSwitchFinder(caret.Line + 1, caret.Column + 1);
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);
}
private void OnToolTipRequest(object sender, TextEditor.ToolTipRequestEventArgs e)
{
if (!e.InDocument || e.ToolTipShown)
return;
IExpressionFinder expressionFinder;
if (IntellisenseForm.SupportedLanguage == SupportedLanguage.VisualBasic)
{
expressionFinder = new VBExpressionFinder();
}
else
{
expressionFinder = new CSharpExpressionFinder(_iForm.ParseInformation);
}
var expression = expressionFinder.FindFullExpression(
_editor.Text,
_editor.Document.PositionToOffset(e.LogicalPosition));
if (expression.Region.IsEmpty)
{
expression.Region = new DomRegion(e.LogicalPosition.Line + 1, e.LogicalPosition.Column + 1);
}
var textArea = _editor.ActiveTextAreaControl.TextArea;
var resolver = new NRefactoryResolver(_iForm.ProjectContent.Language);
var rr = resolver.Resolve(expression,
_iForm.ParseInformation,
textArea.MotherTextEditorControl.Text);
var toolTipText = GetText(rr);
if (toolTipText != null)
{
e.ShowToolTip(toolTipText);
}
}
public WatchListAutoCompleteCell()
{
InitializeComponent();
console = new ConsoleControl();
console.TextAreaTextEntered += new TextCompositionEventHandler(consoleControl_TextAreaTextEntered);
console.TextAreaPreviewKeyDown += new KeyEventHandler(console_TextAreaPreviewKeyDown);
console.LostFocus += new RoutedEventHandler(console_LostFocus);
console.HideScrollBar();
ConsolePanel.Content = console;
// get language
if (ProjectService.CurrentProject == null)
{
language = "C#";
}
else
{
language = ProjectService.CurrentProject.Language;
}
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language));
// FIXME set language
if (language == "VB" || language == "VBNet")
{
console.SetHighlighting("VBNET");
}
else
{
console.SetHighlighting("C#");
}
}
public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver)
{
return CreateReturnType(reference,
resolver.CallingClass, resolver.CallingMember,
resolver.CaretLine, resolver.CaretColumn,
resolver.ProjectContent, ReturnTypeOptions.None);
}
public WatchListAutoCompleteCell()
{
InitializeComponent();
console = new ConsoleControl();
console.TextAreaTextEntered += new TextCompositionEventHandler(consoleControl_TextAreaTextEntered);
console.TextAreaPreviewKeyDown += new KeyEventHandler(console_TextAreaPreviewKeyDown);
console.LostFocus += new RoutedEventHandler(console_LostFocus);
console.HideScrollBar();
ConsolePanel.Content = console;
// get language
if (ProjectService.CurrentProject == null)
language = "C#";
else
language = ProjectService.CurrentProject.Language;
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language));
// FIXME set language
if (language == "VB" || language == "VBNet") {
console.SetHighlighting("VBNET");
}
else {
console.SetHighlighting("C#");
}
// get process
WindowsDebugger debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
debugger.ProcessSelected += delegate(object sender, ProcessEventArgs e) {
this.Process = e.Process;
};
this.Process = debugger.DebuggedProcess;
}
public ConditionCell()
{
InitializeComponent();
console = new ConsoleControl();
console.TextAreaTextEntered += new TextCompositionEventHandler(consoleControl_TextAreaTextEntered);
console.TextAreaPreviewKeyDown += new KeyEventHandler(console_TextAreaPreviewKeyDown);
console.LostFocus += new RoutedEventHandler(console_LostFocus);
console.HideScrollBar();
ConsolePanel.Content = console;
// get language
if (ProjectService.CurrentProject == null)
language = "C#";
else
language = ProjectService.CurrentProject.Language;
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language));
// FIXME set language
if (language == "VB" || language == "VBNet") {
console.SetHighlighting("VBNET");
}
else {
console.SetHighlighting("C#");
}
}
public NRefactoryParameterDataProvider(TextEditorData editor, NRefactoryResolver resolver, ThisResolveResult resolveResult)
{
HashSet <string> alreadyAdded = new HashSet <string> ();
if (resolveResult.CallingType != null)
{
bool includeProtected = true;
foreach (IMethod method in resolveResult.CallingType.Methods)
{
if (!method.IsConstructor)
{
continue;
}
string str = ambience.GetString(method, OutputFlags.IncludeParameters);
if (alreadyAdded.Contains(str))
{
continue;
}
alreadyAdded.Add(str);
if (method.IsAccessibleFrom(resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected))
{
methods.Add(method);
}
}
}
}
public override IEnumerable <MemberReference> FindReferences(ProjectDom dom, FilePath fileName, IEnumerable <INode> searchedMembers)
{
HashSet <int> positions = new HashSet <int> ();
var editor = TextFileProvider.Instance.GetTextEditorData(fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor(editor.Document);
visitor.IncludeXmlDocumentation = IncludeDocumentation;
visitor.Init(searchedMembers);
if (!visitor.FileContainsMemberName())
{
yield break;
}
var doc = ProjectDomService.ParseFile(dom, fileName, () => editor.Text);
if (doc == null || doc.CompilationUnit == null)
{
yield break;
}
var resolver = new NRefactoryResolver(dom, doc.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
visitor.ParseFile(resolver);
visitor.RunVisitor(resolver);
foreach (var reference in visitor.FoundReferences)
{
if (positions.Contains(reference.Position))
{
continue;
}
positions.Add(reference.Position);
yield return(reference);
}
visitor.ClearParsers();
}
protected override void GenerateCompletionData(EditViewControl textArea, char charTyped)
{
if (_forceNewExpression)
{
preSelection = "";
if (charTyped != '\0')
{
preSelection = null;
}
ExpressionContext context = overrideContext;
if (context == null)
{
context = ExpressionContext.Default;
}
NRefactoryResolver rr = Parser.ProjectParser.GetResolver();
AddResolveResults(rr.CtrlSpace(caretLineNumber, caretColumn, fileName, Parser.ProjectParser.GetFileContents(fileName), context), context);
return;
}
ExpressionResult expressionResult = GetExpression(textArea);
string expression = expressionResult.Expression;
preSelection = null;
if (expression == null || expression.Length == 0)
{
preSelection = "";
if (charTyped != '\0')
{
preSelection = null;
}
NRefactoryResolver rr = Parser.ProjectParser.GetResolver();
AddResolveResults(rr.CtrlSpace(caretLineNumber, caretColumn, fileName, Parser.ProjectParser.GetFileContents(fileName), expressionResult.Context), expressionResult.Context);
return;
}
int idx = expression.LastIndexOf('.');
if (idx > 0)
{
preSelection = expression.Substring(idx + 1);
expressionResult.Expression = expression.Substring(0, idx);
if (charTyped != '\0')
{
preSelection = null;
}
GenerateCompletionData(textArea, expressionResult);
}
else
{
preSelection = expression;
if (charTyped != '\0')
{
preSelection = null;
}
ArrayList results = Parser.ProjectParser.GetResolver().CtrlSpace(caretLineNumber, caretColumn, fileName, Parser.ProjectParser.GetFileContents(fileName), expressionResult.Context);
AddResolveResults(results, expressionResult.Context);
}
}
internal InferredReturnType(Expression expression, NRefactoryResolver resolver)
{
if (resolver == null)
throw new ArgumentNullException("resolver");
_expression = expression;
_resolver = resolver;
}
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);
}
void Init(NRefactoryResolver resolver, MonoDevelop.Projects.Dom.INode searchedMember)
{
this.resolver = resolver;
if (searchedMember is IMember)
{
searchedMember = GetUnderlyingMember((IMember)searchedMember);
}
this.searchedMember = searchedMember;
this.IncludeXmlDocumentation = false;
if (searchedMember is IMethod)
{
IMethod method = (IMethod)searchedMember;
this.searchedMemberName = method.IsConstructor ? method.DeclaringType.Name : method.Name;
this.searchedMemberLocation = method.Location;
if (method.DeclaringType != null && method.DeclaringType.CompilationUnit != null)
{
this.searchedMemberFile = method.DeclaringType.CompilationUnit.FileName;
}
}
else if (searchedMember is IMember)
{
this.searchedMemberName = ((IMember)searchedMember).Name;
this.searchedMemberLocation = ((IMember)searchedMember).Location;
if (searchedMember is IType)
{
this.searchedMemberFile = ((IType)searchedMember).CompilationUnit.FileName;
}
else
{
if (((IMember)searchedMember).DeclaringType != null && ((IMember)searchedMember).DeclaringType.CompilationUnit != null)
{
this.searchedMemberFile = ((IMember)searchedMember).DeclaringType.CompilationUnit.FileName;
}
}
}
else if (searchedMember is IParameter)
{
this.searchedMemberName = ((IParameter)searchedMember).Name;
this.searchedMemberLocation = ((IParameter)searchedMember).Location;
if (((IParameter)searchedMember).DeclaringMember.DeclaringType.CompilationUnit != null)
{
this.searchedMemberFile = ((IParameter)searchedMember).DeclaringMember.DeclaringType.CompilationUnit.FileName;
}
}
else if (searchedMember != null)
{
this.searchedMemberName = ((LocalVariable)searchedMember).Name;
this.searchedMemberLocation = ((LocalVariable)searchedMember).Region.Start;
if (((LocalVariable)searchedMember).CompilationUnit != null)
{
this.searchedMemberFile = ((LocalVariable)searchedMember).CompilationUnit.FileName;
}
}
}
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));
}
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));
}
public FindMemberAstVisitor(Mono.TextEditor.Document document, MonoDevelop.Projects.Dom.INode searchedMember = null)
{
fileName = document.FileName;
this.text = document;
this.resolver = resolver;
if (searchedMember != null)
{
Init(searchedMember);
}
}
public static void Format(TextEditorData data, ProjectDom dom, ICompilationUnit unit, DomLocation caretLocation)
{
IType type = NRefactoryResolver.GetTypeAtCursor(unit, unit.FileName, caretLocation);
if (type == null)
{
return;
}
Format(data, type, NRefactoryResolver.GetMemberAt(type, unit.FileName, caretLocation), dom, unit, caretLocation);
}
internal InferredReturnType(Expression expression, NRefactoryResolver resolver)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
_expression = expression;
_resolver = resolver;
}
protected override List <ICompletionEntry> CtrlSpace(ITextEditor editor, ExpressionContext context)
{
var resolver = new NRefactoryResolver(_language);
return(resolver.CtrlSpace(
editor.Caret.Line, editor.Caret.Column,
ParserService.GetParseInformation(editor.Document.Text, _projectContent),
editor.Document.Text,
context, ShowItemsFromAllNamespaces));
}
public NRefactoryTemplateParameterDataProvider(TextEditorData editor, NRefactoryResolver resolver, IEnumerable <string> namespaces, ExpressionResult expressionResult, DomLocation loc)
{
// this.editor = editor;
ResolveResult plainResolveResult = resolver.Resolve(expressionResult, loc);
MethodResolveResult resolveResult = plainResolveResult as MethodResolveResult;
if (resolveResult != null)
{
foreach (IMethod method in resolveResult.Methods)
{
if (method.TypeParameters.Count > 0)
{
this.types.Add(method);
}
}
}
else
{
string typeName = expressionResult.Expression.Trim();
foreach (string ns in namespaces)
{
string prefix = ns + (ns.Length > 0 ? "." : "") + typeName + "`";
for (int i = 1; i < 99; i++)
{
IType possibleType = resolver.Dom.GetType(prefix + i);
if (possibleType != null)
{
this.types.Add(possibleType);
}
}
}
IType resolvedType = plainResolveResult != null?resolver.Dom.GetType(plainResolveResult.ResolvedType) : null;
if (resolvedType == null)
{
int idx = expressionResult.Expression.LastIndexOf(".");
if (idx < 0)
{
return;
}
typeName = expressionResult.Expression.Substring(idx + 1);
expressionResult.Expression = expressionResult.Expression.Substring(0, idx);
plainResolveResult = resolver.Resolve(expressionResult, loc);
resolvedType = resolver.Dom.GetType(plainResolveResult.ResolvedType);
}
if (resolvedType == null)
{
return;
}
foreach (IType innerType in resolvedType.InnerTypes)
{
this.types.Add(innerType);
}
}
}
public ResolveResult Resolve(string program, string expression, int line)
{
AddCompilationUnit(Parse("a.cs", program), "a.cs");
NRefactoryResolver resolver = new NRefactoryResolver(lastPC, LanguageProperties.CSharp);
return(resolver.Resolve(new ExpressionResult(expression),
line, 0,
"a.cs",
program));
}
/// <summary>
/// Do not call from your Context actions - used by SharpDevelop.
/// Sets contents of editor context to null to prevent memory leaks. Used in case users implementing IContextActionProvider
/// keep long-lived references to EditorContext even when warned not to do so.
/// </summary>
public void Clear()
{
this.Editor = null;
this.CurrentElement = null;
this.CurrentLineAST = null;
this.CurrentMemberAST = null;
this.CurrentParseInformation = null;
this.CurrentSymbol = null;
this.Resolver = null;
this.cachedValues.Clear();
}
public override IEnumerable <MemberReference> FindClassReferences(RefactorerContext ctx, string fileName, IType cls, bool includeXmlComment)
{
IEditableTextFile file = ctx.GetFile(fileName);
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, cls.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor(resolver, file, cls);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor();
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
public void SetupDataProvider(string fileName)
{
IExpressionFinder expressionFinder;
if (IntellisenseForm.SupportedLanguage == ESupportedLanguage.VisualBasic)
{
expressionFinder = new VBExpressionFinder();
}
else
{
expressionFinder = new CSharpExpressionFinder(iForm.ParseInformation);
}
//TextLocation position = m_textarea.Caret.Position;
//ExpressionResult expression = expressionFinder.FindFullExpression(m_textarea.MotherTextEditorControl.Text, m_textarea.Document.PositionToOffset(position));
//if (expression.Region.IsEmpty)
//{
// expression.Region = new DomRegion(position.Line + 1, position.Column + 1);
//}
ExpressionResult expression = expressionFinder.FindFullExpression(
m_textarea.MotherTextEditorControl.Text,
m_textarea.MotherTextEditorControl.Document.PositionToOffset(m_textarea.Caret.Position) - 1);
if (expression.Region.IsEmpty)
{
expression.Region = new DomRegion(m_textarea.Caret.Position.Line + 1, m_textarea.Caret.Position.Column + 1);
}
NRefactoryResolver resolver = new NRefactoryResolver(iForm.ProjectContent.Language);
ResolveResult rr = resolver.Resolve(expression, iForm.ParseInformation, m_textarea.MotherTextEditorControl.Text);
List <string> lines = new List <string>();
if (rr is MethodGroupResolveResult)
{
MethodGroupResolveResult mrr = rr as MethodGroupResolveResult;
IAmbience ambience = IntellisenseForm.SupportedLanguage == ESupportedLanguage.VisualBasic ? (IAmbience) new VBNetAmbience() : new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowAccessibility;
foreach (MethodGroup methodgroup in mrr.Methods)
{
foreach (IMethod method in methodgroup)
{
lines.Add(ToolTipProvider.GetMemberText(ambience, method));
}
}
}
m_insighttext = (lines.Count > 0) ? lines.ToArray() : null;
m_argumentstartoffset = m_textarea.Caret.Offset;
}
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);
}
// used for constructor completion
public NRefactoryParameterDataProvider(TextEditorData editor, NRefactoryResolver resolver, IType type)
{
if (type != null)
{
if (type.ClassType == ClassType.Delegate)
{
IMethod invokeMethod = ExtractInvokeMethod(type);
if (type is InstantiatedType)
{
this.delegateName = ((InstantiatedType)type).UninstantiatedType.Name;
}
else
{
this.delegateName = type.Name;
}
if (invokeMethod != null)
{
methods.Add(invokeMethod);
}
else
{
// no invoke method -> tried to create an abstract delegate
}
return;
}
bool includeProtected = DomType.IncludeProtected(resolver.Dom, type, resolver.CallingType);
bool constructorFound = false;
HashSet <string> alreadyAdded = new HashSet <string> ();
foreach (IMethod method in type.Methods)
{
constructorFound |= method.IsConstructor;
string str = ambience.GetString(method, OutputFlags.IncludeParameters);
if (alreadyAdded.Contains(str))
{
continue;
}
alreadyAdded.Add(str);
if ((method.IsConstructor && method.IsAccessibleFrom(resolver.Dom, type, resolver.CallingMember, includeProtected)))
{
methods.Add(method);
}
}
// No constructor - generating default
if (!constructorFound && (type.TypeModifier & TypeModifier.HasOnlyHiddenConstructors) != TypeModifier.HasOnlyHiddenConstructors)
{
DomMethod defaultConstructor = new DomMethod();
defaultConstructor.MethodModifier = MethodModifier.IsConstructor;
defaultConstructor.DeclaringType = type;
methods.Add(defaultConstructor);
}
}
}
internal LambdaReturnType(AnonymousMethodExpression expression, NRefactoryResolver resolver)
: base(resolver.CompilationUnit)
{
this.resolver = resolver;
if (expression.HasParameterList) {
base.MethodParameters = new List<IParameter>();
foreach (ParameterDeclarationExpression param in expression.Parameters) {
base.MethodParameters.Add(NRefactoryASTConvertVisitor.CreateParameter(param, resolver.CallingMember as IMethod, resolver.CallingClass, resolver.CompilationUnit));
}
}
expression.Body.AcceptVisitor(new ReturnStatementFinder(returnExpressions), null);
}
void OnLanguageChanged()
{
switch (SelectedLanguage) {
case SupportedLanguage.CSharp:
resolver = new NRefactoryResolver(LanguageProperties.CSharp);
SetHighlighting("C#");
break;
case SupportedLanguage.VBNet:
resolver = new NRefactoryResolver(LanguageProperties.VBNet);
SetHighlighting("VBNET");
break;
}
}
IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, INode member)
{
var editor = TextFileProvider.Instance.GetTextEditorData (fileName);
var doc = ProjectDomService.GetParsedDocument (dom, fileName);
if (doc == null || doc.CompilationUnit == null)
return null;
var resolver = new NRefactoryResolver (dom, doc.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document, resolver, member);
visitor.IncludeXmlDocumentation = IncludeDocumentation;
visitor.RunVisitor ();
return visitor.FoundReferences;
}
public LambdaParameterReturnType(LambdaExpression lambda, string name, NRefactoryResolver resolver)
{
if (lambda == null)
throw new ArgumentNullException("lambda");
if (name == null)
throw new ArgumentNullException("name");
if (resolver == null)
throw new ArgumentNullException("resolver");
this.lambda = lambda;
this.parameterName = name;
this.parameterIndex = lambda.Parameters.FindIndex(p => p.ParameterName == name);
this.resolver = resolver;
if (parameterIndex < 0)
throw new ArgumentException("there is no lambda parameter with that name");
}
internal LambdaReturnType(LambdaExpression expression, NRefactoryResolver resolver)
: base(resolver.CompilationUnit)
{
this.resolver = resolver;
this.lambdaExpression = expression;
base.MethodParameters = new List<IParameter>();
foreach (ParameterDeclarationExpression param in expression.Parameters) {
base.MethodParameters.Add(NRefactoryASTConvertVisitor.CreateParameter(param, resolver.CallingMember as IMethod, resolver.CallingClass, resolver.CompilationUnit));
}
if (expression.ExpressionBody.IsNull)
expression.StatementBody.AcceptVisitor(new ReturnStatementFinder(returnExpressions), null);
else
returnExpressions.Add(expression.ExpressionBody);
}
public NRefactoryParameterDataProvider (TextEditorData editor, NRefactoryResolver resolver, MethodResolveResult resolveResult)
{
this.staticResolve = resolveResult.StaticResolve;
bool includeProtected = true;
HashSet<string> alreadyAdded = new HashSet<string> ();
foreach (IMethod method in resolveResult.Methods) {
if (method.IsConstructor)
continue;
string str = ambience.GetString (method, OutputFlags.IncludeParameters | OutputFlags.GeneralizeGenerics | OutputFlags.IncludeGenerics);
if (alreadyAdded.Contains (str))
continue;
alreadyAdded.Add (str);
if (method.IsAccessibleFrom (resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected))
methods.Add (method);
}
methods.Sort (MethodComparer);
}
IEnumerable<MemberReference> SearchMember (INode member, ProjectDom dom, FilePath fileName, Mono.TextEditor.TextEditorData editor, Mono.TextEditor.Document buildDocument, List<LocalDocumentInfo.OffsetInfo> offsetInfos, ParsedDocument parsedDocument)
{
var resolver = new NRefactoryResolver (dom, parsedDocument.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor (buildDocument, member);
visitor.IncludeXmlDocumentation = IncludeDocumentation;
visitor.RunVisitor (resolver);
foreach (var result in visitor.FoundReferences) {
var offsetInfo = offsetInfos.FirstOrDefault (info => info.ToOffset <= result.Position && result.Position < info.ToOffset + info.Length);
if (offsetInfo == null)
continue;
var offset = offsetInfo.FromOffset + result.Position - offsetInfo.ToOffset;
var loc = editor.OffsetToLocation (offset);
yield return new MemberReference (null, fileName, offset, loc.Line, loc.Column, result.Name, null);
}
}
public NRefactoryParameterDataProvider (TextEditorData editor, NRefactoryResolver resolver, ThisResolveResult resolveResult)
{
HashSet<string> alreadyAdded = new HashSet<string> ();
if (resolveResult.CallingType != null) {
bool includeProtected = true;
foreach (IMethod method in resolveResult.CallingType.Methods) {
if (!method.IsConstructor)
continue;
string str = ambience.GetString (method, OutputFlags.IncludeParameters);
if (alreadyAdded.Contains (str))
continue;
alreadyAdded.Add (str);
if (method.IsAccessibleFrom (resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected))
methods.Add (method);
}
}
}
public override IEnumerable<MemberReference> FindReferences (ProjectDom dom, FilePath fileName, INode member)
{
var editor = TextFileProvider.Instance.GetTextEditorData (fileName);
AspNetAppProject project = dom.Project as AspNetAppProject;
System.Console.WriteLine ("project:" + project);
if (project == null)
yield break;
var unit = AspNetParserService.GetCompileUnit (project, fileName, true);
System.Console.WriteLine ("unit:" + unit);
if (unit == null)
yield break;
System.Console.WriteLine ("go ");
var refman = new DocumentReferenceManager (project);
var parsedAspDocument = (AspNetParsedDocument)new AspNetParser ().Parse (dom, fileName, editor.Text);
refman.Doc = parsedAspDocument;
var usings = refman.GetUsings ();
var documentInfo = new DocumentInfo (unit, usings, refman.GetDoms ());
var builder = new AspLanguageBuilder ();
var buildDocument = new Mono.TextEditor.Document ();
var offsetInfos = new List<LocalDocumentInfo.OffsetInfo> ();
buildDocument.Text = builder.BuildDocumentString (documentInfo, editor, offsetInfos, true);
var parsedDocument = AspLanguageBuilder.Parse (fileName, buildDocument.Text);
var resolver = new NRefactoryResolver (dom, parsedDocument.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor (buildDocument, resolver, member);
visitor.IncludeXmlDocumentation = IncludeDocumentation;
visitor.RunVisitor ();
foreach (var result in visitor.FoundReferences) {
var offsetInfo = offsetInfos.FirstOrDefault (info => info.ToOffset <= result.Position && result.Position < info.ToOffset + info.Length);
if (offsetInfo == null)
continue;
var offset = offsetInfo.FromOffset + result.Position - offsetInfo.ToOffset;
var loc = editor.OffsetToLocation (offset);
yield return new MemberReference (null, fileName, offset, loc.Line, loc.Column, result.Name, null);
}
}
public NRefactoryTemplateParameterDataProvider (TextEditorData editor, NRefactoryResolver resolver, IEnumerable<string> namespaces, ExpressionResult expressionResult, DomLocation loc)
{
// this.editor = editor;
ResolveResult plainResolveResult = resolver.Resolve (expressionResult, loc);
MethodResolveResult resolveResult = plainResolveResult as MethodResolveResult;
if (resolveResult != null) {
foreach (IMethod method in resolveResult.Methods) {
if (method.TypeParameters.Count > 0)
this.types.Add (method);
}
} else {
string typeName = expressionResult.Expression.Trim ();
foreach (string ns in namespaces) {
string prefix = ns + (ns.Length > 0 ? "." : "") + typeName + "`";
for (int i = 1; i < 99; i++) {
IType possibleType = resolver.Dom.GetType (prefix + i);
if (possibleType != null)
this.types.Add (possibleType);
}
}
IType resolvedType = plainResolveResult != null ? resolver.Dom.GetType (plainResolveResult.ResolvedType) : null;
if (resolvedType == null) {
int idx = expressionResult.Expression.LastIndexOf (".");
if (idx < 0)
return;
typeName = expressionResult.Expression.Substring (idx + 1);
expressionResult.Expression = expressionResult.Expression.Substring (0, idx);
plainResolveResult = resolver.Resolve (expressionResult, loc);
resolvedType = resolver.Dom.GetType (plainResolveResult.ResolvedType);
}
if (resolvedType == null)
return;
foreach (IType innerType in resolvedType.InnerTypes) {
this.types.Add (innerType);
}
}
}
ICompletionDataList CreateCompletionData (DomLocation location, ResolveResult resolveResult,
ExpressionResult expressionResult, NRefactoryResolver resolver)
{
if (resolveResult == null || expressionResult == null || dom == null)
return null;
CompletionDataList result = new ProjectDomCompletionDataList ();
IEnumerable<object> objects = resolveResult.CreateResolveResult (dom, resolver != null ? resolver.CallingMember : null);
CompletionDataCollector col = new CompletionDataCollector (dom, result, Document.CompilationUnit, resolver != null ? resolver.CallingType : null, location);
col.HideExtensionParameter = !resolveResult.StaticResolve;
col.NamePrefix = expressionResult.Expression;
bool showOnlyTypes = expressionResult.Contexts.Any (ctx => ctx == ExpressionContext.InheritableType || ctx == ExpressionContext.Constraints);
if (objects != null) {
foreach (object obj in objects) {
if (expressionResult.ExpressionContext != null && expressionResult.ExpressionContext.FilterEntry (obj))
continue;
if (expressionResult.ExpressionContext == ExpressionContext.NamespaceNameExcepted && !(obj is Namespace))
continue;
if (showOnlyTypes && !(obj is IType))
continue;
CompletionData data = col.Add (obj);
if (data != null && expressionResult.ExpressionContext == ExpressionContext.Attribute && data.CompletionText != null && data.CompletionText.EndsWith ("Attribute")) {
string newText = data.CompletionText.Substring (0, data.CompletionText.Length - "Attribute".Length);
data.SetText (newText);
}
}
}
return result;
}
public override IEnumerable<MemberReference> FindParameterReferences (RefactorerContext ctx, string fileName, IParameter param, bool includeXmlComment)
{
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, param.DeclaringMember.DeclaringType.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
resolver.CallingMember = param.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (resolver, ctx.GetFile (fileName), param);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
public override IEnumerable<MemberReference> FindVariableReferences (RefactorerContext ctx, string fileName, LocalVariable var)
{
//System.Console.WriteLine("Find variable references !!!");
// ParsedDocument parsedDocument = ProjectDomService.ParseFile (fileName);
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, var.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
resolver.CallingMember = var.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (resolver, ctx.GetFile (fileName), var);
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
public override IEnumerable<MemberReference> FindMemberReferences (RefactorerContext ctx, string fileName, IType cls, IMember member, bool includeXmlComment)
{
ParsedDocument parsedDocument = parser.Parse (cls.SourceProjectDom, fileName, ctx.GetFile (fileName).Text);
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, parsedDocument.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
resolver.SetupParsedCompilationUnit (parser.LastUnit);
resolver.CallingMember = member;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (resolver, ctx.GetFile (fileName), member);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
public override IEnumerable<MemberReference> FindClassReferences (RefactorerContext ctx, string fileName, IType cls, bool includeXmlComment)
{
IEditableTextFile file = ctx.GetFile (fileName);
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, cls.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor (resolver, file, cls);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
public override IEnumerable<MemberReference> FindVariableReferences (RefactorerContext ctx, string fileName, LocalVariable var)
{
var editor = ((Mono.TextEditor.ITextEditorDataProvider)ctx.GetFile (fileName)).GetTextEditorData ();
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, var.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
resolver.CallingMember = var.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document, resolver, var);
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
public override IEnumerable<MemberReference> FindMemberReferences (RefactorerContext ctx, string fileName, IType cls, IMember member, bool includeXmlComment)
{
var editor = ((Mono.TextEditor.ITextEditorDataProvider)ctx.GetFile (fileName)).GetTextEditorData ();
var doc = ProjectDomService.GetParsedDocument (ctx.ParserContext, fileName);
if (doc == null || doc.CompilationUnit == null)
return null;
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, doc.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
resolver.CallingMember = member;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document, resolver, member);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
NRefactoryResolver CreateResolver ()
{
NRefactoryResolver result = new NRefactoryResolver (dom, Document.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, textEditorData, Document.FileName);
if (ParsedUnit != null)
result.SetupParsedCompilationUnit (ParsedUnit);
return result;
}
List<MonoDevelop.Projects.CodeGeneration.MemberReference> GetReferences (ResolveResult resolveResult)
{
INode member = null;
if (resolveResult is MemberResolveResult) {
member = ((MemberResolveResult)resolveResult).ResolvedMember;
if (member == null)
member = dom.GetType (resolveResult.ResolvedType);
}
if (resolveResult is ParameterResolveResult)
member = ((ParameterResolveResult)resolveResult).Parameter;
if (resolveResult is LocalVariableResolveResult)
member = ((LocalVariableResolveResult)resolveResult).LocalVariable;
if (member != null) {
try {
ICompilationUnit compUnit = Document.CompilationUnit;
if (compUnit == null)
return null;
NRefactoryResolver resolver = new NRefactoryResolver (dom, compUnit, ICSharpCode.OldNRefactory.SupportedLanguage.CSharp, Document.Editor, Document.FileName);
if (member is LocalVariable)
resolver.CallingMember = ((LocalVariable)member).DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (textEditorData.Document, member);
visitor.IncludeXmlDocumentation = true;
/* ICSharpCode.OldNRefactory.Ast.CompilationUnit unit = compUnit.Tag as ICSharpCode.OldNRefactory.Ast.CompilationUnit;
if (unit == null)
return null;*/
visitor.RunVisitor (resolver);
return visitor.FoundReferences;
} catch (Exception e) {
LoggingService.LogError ("Error in highlight usages extension.", e);
}
}
return null;
}
public CompletionDataList CreateParameterCompletion (NRefactoryResolver resolver, DomLocation location, ExpressionContext context, IEnumerable<IMethod> possibleMethods, int parameter)
{
CompletionDataList completionList = new ProjectDomCompletionDataList ();
var addedEnums = new HashSet<string> ();
var addedDelegates = new HashSet<string> ();
IType resolvedType = null;
foreach (var method in possibleMethods) {
if (method.Parameters.Count <= parameter)
continue;
resolvedType = dom.GetType (method.Parameters [parameter].ReturnType);
if (resolvedType == null)
continue;
switch (resolvedType.ClassType) {
case MonoDevelop.Projects.Dom.ClassType.Enum:
if (addedEnums.Contains (resolvedType.DecoratedFullName))
continue;
addedEnums.Add (resolvedType.DecoratedFullName);
AddEnumMembers (completionList, resolvedType);
break;
case MonoDevelop.Projects.Dom.ClassType.Delegate:
if (addedDelegates.Contains (resolvedType.DecoratedFullName))
continue;
addedDelegates.Add (resolvedType.DecoratedFullName);
string parameterDefinition = AddDelegateHandlers (completionList, resolvedType, false, addedDelegates.Count == 1);
string varName = "Handle" + method.Parameters [parameter].ReturnType.Name + method.Parameters [parameter].Name;
completionList.Add (new EventCreationCompletionData (textEditorData, varName, resolvedType, null, parameterDefinition, resolver.Unit.GetMemberAt (location), resolvedType) { AddSemicolon = false });
break;
}
}
if (addedEnums.Count + addedDelegates.Count == 0)
return null;
CompletionDataCollector cdc = new CompletionDataCollector (this, dom, completionList, Document.CompilationUnit, resolver.CallingType, location);
completionList.AutoCompleteEmptyMatch = false;
completionList.AutoSelect = false;
resolver.AddAccessibleCodeCompletionData (ExpressionContext.MethodBody, cdc);
if (addedDelegates.Count > 0) {
foreach (var data in completionList) {
if (data is MemberCompletionData)
((MemberCompletionData)data).IsDelegateExpected = true;
}
}
return completionList;
}
