public ResolveResult Resolve(ExpressionResult expressionResult, DomLocation resolvePosition)
{
this.SetupResolver(resolvePosition);
ResolveVisitor visitor = new ResolveVisitor(this);
ResolveResult result;
// System.Console.WriteLine("expressionResult:" + expressionResult);
if (unit != null && expressionResult.ExpressionContext == ExpressionContext.AttributeArguments)
{
string attributeName = NewCSharpExpressionFinder.FindAttributeName(editor, unit, unit.FileName);
if (attributeName != null)
{
IType type = SearchType(attributeName + "Attribute");
if (type == null)
{
type = SearchType(attributeName);
}
if (type != null)
{
foreach (IProperty property in type.Properties)
{
if (property.Name == expressionResult.Expression)
{
return(new MemberResolveResult(property));
}
}
}
}
}
TypeReference typeRef;
if (expressionResult != null && expressionResult.ExpressionContext != null && expressionResult.ExpressionContext.IsObjectCreation)
{
typeRef = ParseTypeReference(expressionResult);
if (typeRef != null)
{
if (dom.NamespaceExists(typeRef.Type))
{
// System.Console.WriteLine("namespace resolve result");
result = new NamespaceResolveResult(typeRef.Type);
}
else
{
result = visitor.CreateResult(ConvertTypeReference(typeRef));
}
// System.Console.WriteLine("type reference resolve result");
result.ResolvedExpression = expressionResult;
if (dom.GetType(result.ResolvedType) != null)
{
return(result);
}
}
}
expr = ParseExpression(expressionResult);
// System.Console.WriteLine("parsed expression:" + expr);
if (expr == null)
{
// System.Console.WriteLine("Can't parse expression");
return(null);
}
result = visitor.Resolve(expr);
// if (CallingMember == null && result != null)
// result.StaticResolve = true;
// System.Console.WriteLine("result:" + result + "STATIC" + result.StaticResolve);
result.ResolvedExpression = expressionResult;
return(result);
}
internal static RefactoringOptions CreateRefactoringOptions(string text)
{
int cursorPosition = -1;
int endPos = text.IndexOf('$');
if (endPos >= 0)
{
cursorPosition = endPos;
text = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
}
int selectionStart = -1;
int selectionEnd = -1;
int idx = text.IndexOf("<-");
if (idx >= 0)
{
selectionStart = idx;
text = text.Substring(0, idx) + text.Substring(idx + 2);
selectionEnd = idx = text.IndexOf("->");
text = text.Substring(0, idx) + text.Substring(idx + 2);
if (cursorPosition < 0)
{
cursorPosition = selectionEnd - 1;
}
}
TestWorkbenchWindow tww = new TestWorkbenchWindow();
TestViewContent sev = new TestViewContent();
// return new RefactoringOptions ();
DotNetProject project = new DotNetAssemblyProject("C#");
Solution solution = new Solution();
solution.RootFolder.Items.Add(project);
project.FileName = GetTempFile(".csproj");
string file = GetTempFile(".cs");
project.AddFile(file);
string parsedText = text;
string editorText = text;
ProjectDomService.Load(project);
ProjectDom dom = ProjectDomService.GetProjectDom(project);
dom.ForceUpdate(true);
ProjectDomService.Parse(project, file, delegate { return(parsedText); });
ProjectDomService.Parse(project, file, delegate { return(parsedText); });
sev.Project = project;
sev.ContentName = file;
sev.Text = editorText;
sev.CursorPosition = cursorPosition;
tww.ViewContent = sev;
var doc = new MonoDevelop.Ide.Gui.Document(tww);
doc.Editor.Document.MimeType = "text/x-csharp";
doc.Editor.Document.FileName = file;
doc.ParsedDocument = new McsParser().Parse(null, sev.ContentName, parsedText);
foreach (var e in doc.ParsedDocument.Errors)
{
Console.WriteLine(e);
}
if (cursorPosition >= 0)
{
doc.Editor.Caret.Offset = cursorPosition;
}
if (selectionStart >= 0)
{
doc.Editor.SetSelection(selectionStart, selectionEnd);
}
NRefactoryResolver resolver = new NRefactoryResolver(dom,
doc.ParsedDocument.CompilationUnit,
sev.Data,
file);
ExpressionResult expressionResult;
if (selectionStart >= 0)
{
expressionResult = new ExpressionResult(editorText.Substring(selectionStart, selectionEnd - selectionStart).Trim());
endPos = selectionEnd;
}
else
{
expressionResult = new NewCSharpExpressionFinder(dom).FindFullExpression(doc.Editor, cursorPosition + 1);
}
ResolveResult resolveResult = endPos >= 0 ? resolver.Resolve(expressionResult, new DomLocation(doc.Editor.Caret.Line, doc.Editor.Caret.Column)) : null;
RefactoringOptions result = new RefactoringOptions {
Document = doc,
Dom = dom,
ResolveResult = resolveResult,
SelectedItem = null
};
if (resolveResult is MemberResolveResult)
{
result.SelectedItem = ((MemberResolveResult)resolveResult).ResolvedMember;
}
if (resolveResult is LocalVariableResolveResult)
{
result.SelectedItem = ((LocalVariableResolveResult)resolveResult).LocalVariable;
}
if (resolveResult is ParameterResolveResult)
{
result.SelectedItem = ((ParameterResolveResult)resolveResult).Parameter;
}
result.TestFileProvider = new FileProvider(result);
return(result);
}
public MonoDevelop.Projects.Dom.ResolveResult GetLanguageItem(ProjectDom dom, Mono.TextEditor.TextEditorData data, int offset)
{
if (offset < 0)
{
return(null);
}
string fileName = data.Document.FileName;
IParser parser = ProjectDomService.GetParser(fileName);
if (parser == null)
{
return(null);
}
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
if (doc == null)
{
return(null);
}
IResolver resolver = parser.CreateResolver(dom, doc, fileName);
if (resolver == null)
{
return(null);
}
var expressionFinder = new NewCSharpExpressionFinder(dom);
int wordEnd = Math.Min(offset, data.Length - 1);
if (wordEnd < 0)
{
return(null);
}
if (data.GetCharAt(wordEnd) == '@')
{
wordEnd++;
}
while (wordEnd < data.Length && (Char.IsLetterOrDigit(data.GetCharAt(wordEnd)) || data.GetCharAt(wordEnd) == '_'))
{
wordEnd++;
}
while (wordEnd < data.Length - 1 && Char.IsWhiteSpace(data.GetCharAt(wordEnd)))
{
wordEnd++;
}
/* is checked at the end.
* int saveEnd = wordEnd;
* if (wordEnd < data.Length && data.GetCharAt (wordEnd) == '<') {
* int matchingBracket = data.Document.GetMatchingBracketOffset (wordEnd);
* if (matchingBracket > 0)
* wordEnd = matchingBracket;
* while (wordEnd < data.Length - 1 && Char.IsWhiteSpace (data.GetCharAt (wordEnd)))
* wordEnd++;
* }
*
* bool wasMethodCall = false;
* if (data.GetCharAt (wordEnd) == '(') {
* int matchingBracket = data.Document.GetMatchingBracketOffset (wordEnd);
* if (matchingBracket > 0) {
* wordEnd = matchingBracket;
* wasMethodCall = true;
* }
* }
* if (!wasMethodCall)
* wordEnd = saveEnd;*/
ExpressionResult expressionResult = expressionFinder.FindExpression(data, wordEnd);
if (expressionResult == null)
{
return(null);
}
ResolveResult resolveResult;
DocumentLocation loc = data.Document.OffsetToLocation(offset);
string savedExpression = null;
// special handling for 'var' "keyword"
if (expressionResult.ExpressionContext == ExpressionContext.IdentifierExpected && expressionResult.Expression != null && expressionResult.Expression.Trim() == "var")
{
int endOffset = data.Document.LocationToOffset(expressionResult.Region.End.Line, expressionResult.Region.End.Column);
StringBuilder identifer = new StringBuilder();
for (int i = endOffset; i >= 0 && i < data.Document.Length; i++)
{
char ch = data.Document.GetCharAt(i);
if (Char.IsWhiteSpace(ch))
{
continue;
}
if (ch == '=')
{
break;
}
if (Char.IsLetterOrDigit(ch) || ch == '_')
{
identifer.Append(ch);
continue;
}
identifer.Length = 0;
break;
}
if (identifer.Length > 0)
{
expressionResult.Expression = identifer.ToString();
resolveResult = resolver.Resolve(expressionResult, new DomLocation(loc.Line, loc.Column));
if (resolveResult != null)
{
resolveResult = new MemberResolveResult(dom.GetType(resolveResult.ResolvedType));
resolveResult.ResolvedExpression = expressionResult;
return(resolveResult);
}
}
}
if (expressionResult.ExpressionContext == ExpressionContext.Attribute && !string.IsNullOrEmpty(expressionResult.Expression))
{
savedExpression = expressionResult.Expression;
expressionResult.Expression = expressionResult.Expression.Trim() + "Attribute";
expressionResult.ExpressionContext = ExpressionContext.ObjectCreation;
}
resolveResult = resolver.Resolve(expressionResult, new DomLocation(loc.Line, loc.Column));
if (savedExpression != null && resolveResult == null)
{
expressionResult.Expression = savedExpression;
resolveResult = resolver.Resolve(expressionResult, new DomLocation(loc.Line, loc.Column));
}
// Search for possible generic parameters.
// if (this.resolveResult == null || this.resolveResult.ResolvedType == null || String.IsNullOrEmpty (this.resolveResult.ResolvedType.Name)) {
if (!expressionResult.Region.IsEmpty)
{
int j = data.Document.LocationToOffset(expressionResult.Region.End.Line, expressionResult.Region.End.Column);
int bracket = 0;
for (int i = j; i >= 0 && i < data.Document.Length; i++)
{
char ch = data.Document.GetCharAt(i);
if (Char.IsWhiteSpace(ch))
{
continue;
}
if (ch == '<')
{
bracket++;
}
else if (ch == '>')
{
bracket--;
if (bracket == 0)
{
expressionResult.Expression += data.Document.GetTextBetween(j, i + 1);
expressionResult.ExpressionContext = ExpressionContext.ObjectCreation;
resolveResult = resolver.Resolve(expressionResult, new DomLocation(loc.Line, loc.Column));
break;
}
}
else
{
if (bracket == 0)
{
break;
}
}
}
}
// To resolve method overloads the full expression must be parsed.
// ex.: Overload (1)/ Overload("one") - parsing "Overload" gives just a MethodResolveResult
// and for constructor initializers it's tried too to to resolve constructor overloads.
if (resolveResult is ThisResolveResult ||
resolveResult is BaseResolveResult ||
resolveResult is MethodResolveResult && ((MethodResolveResult)resolveResult).Methods.Count > 1)
{
// put the search offset at the end of the invocation to be able to find the full expression
// the resolver finds it itself if spaces are between the method name and the argument opening parentheses.
while (wordEnd < data.Length - 1 && Char.IsWhiteSpace(data.GetCharAt(wordEnd)))
{
wordEnd++;
}
if (data.GetCharAt(wordEnd) == '(')
{
int matchingBracket = data.Document.GetMatchingBracketOffset(wordEnd);
if (matchingBracket > 0)
{
wordEnd = matchingBracket;
}
}
//Console.WriteLine (expressionFinder.FindFullExpression (txt, wordEnd));
ResolveResult possibleResult = resolver.Resolve(expressionFinder.FindFullExpression(data, wordEnd), new DomLocation(loc.Line, loc.Column)) ?? resolveResult;
//Console.WriteLine ("possi:" + resolver.Resolve (expressionFinder.FindFullExpression (txt, wordEnd), new DomLocation (loc.Line, loc.Column)));
if (possibleResult is MethodResolveResult)
{
resolveResult = possibleResult;
}
}
return(resolveResult);
}
