public override List <Change> PerformChanges(RefactoringOptions options, object properties)
{
List <Change> result = new List <Change> ();
ICSharpCode.NRefactory.CSharp.CompilationUnit unit = options.GetASTProvider().ParseFile(options.Document.Editor.Text);
FindTypeReferencesVisitor visitor = new FindTypeReferencesVisitor(options.GetTextEditorData(), options.GetResolver());
visitor.VisitCompilationUnit(unit, null);
ProjectDom dom = options.Dom;
ICompilationUnit compilationUnit = options.ParseDocument().CompilationUnit;
HashSet <string> usedUsings = new HashSet <string> ();
foreach (var r in visitor.PossibleTypeReferences)
{
if (r is PrimitiveType)
{
continue;
}
IType type = dom.SearchType(compilationUnit, options.ResolveResult != null ? options.ResolveResult.CallingType : null, new DomLocation(options.Document.Editor.Caret.Line, options.Document.Editor.Caret.Column), r.ConvertToReturnType());
if (type != null)
{
usedUsings.Add(type.Namespace);
}
}
Mono.TextEditor.TextEditorData textEditorData = options.GetTextEditorData();
HashSet <string> currentUsings = new HashSet <string> ();
foreach (IUsing u in compilationUnit.Usings)
{
if (u.IsFromNamespace)
{
continue;
}
if (!u.Aliases.Any() && u.Namespaces.All(name => currentUsings.Contains(name) || !usedUsings.Contains(name)))
{
TextReplaceChange change = new TextReplaceChange();
change.FileName = options.Document.FileName;
change.Offset = textEditorData.Document.LocationToOffset(u.Region.Start.Line, u.Region.Start.Column);
change.RemovedChars = textEditorData.Document.LocationToOffset(u.Region.End.Line, u.Region.End.Column) - change.Offset;
Mono.TextEditor.LineSegment line = textEditorData.Document.GetLineByOffset(change.Offset);
if (line != null && line.EditableLength == change.RemovedChars)
{
change.RemovedChars += line.DelimiterLength;
}
result.Add(change);
}
foreach (string nspace in u.Namespaces)
{
currentUsings.Add(nspace);
}
}
return(result);
}
public InstantiatedParameterType(ProjectDom dom, ITypeParameterMember typeParameterMember, ITypeParameter tp)
{
IType outerType = typeParameterMember as IType ?? typeParameterMember.DeclaringType;
typeparam = tp;
compilationUnit = outerType.CompilationUnit;
ClassType = ClassType.Class;
Modifiers = Modifiers.Public;
Name = tp.Name;
Namespace = outerType.DecoratedFullName;
Location = outerType.Location;
DeclaringType = outerType;
if (tp.ValueTypeRequired)
{
BaseType = new DomReturnType("System.ValueType");
}
if (tp.Constraints.Count > 0)
{
ClassType = ClassType.Interface;
}
foreach (IReturnType rt in tp.Constraints)
{
if (FindCyclicReference(new HashSet <ITypeParameter> ()
{
tp
}, outerType, ((DomReturnType)rt).DecoratedFullName))
{
continue;
}
IType bt = dom.SearchType(typeParameterMember, rt);
IReturnType resolvedType = rt;
if (bt != null)
{
resolvedType = new DomReturnType(bt);
if (bt.ClassType == ClassType.Interface || BaseType != null)
{
AddInterfaceImplementation(resolvedType);
}
else
{
ClassType = bt.ClassType;
BaseType = resolvedType;
}
}
else
{
AddInterfaceImplementation(resolvedType);
}
}
if (BaseType == null)
{
BaseType = DomReturnType.Object;
}
}
public override IEnumerable <object> CreateResolveResult(ProjectDom dom, IMember callingMember)
{
List <object> result = new List <object> ();
if (CallingMember != null && !CallingMember.IsStatic)
{
IType baseType = dom.SearchType(CallingType != null ? CallingType.CompilationUnit : null, CallingType, CallingMember.Location, CallingType.BaseType ?? DomReturnType.Object);
MemberResolveResult.AddType(dom, result, baseType, new BaseMemberDecorator(CallingMember, baseType), StaticResolve, m => m.IsAbstract);
}
return(result);
}
public bool IsCompatible(IReturnType baseType, IReturnType type)
{
if (baseType.ToInvariantString() == type.ToInvariantString())
{
return(true);
}
ProjectDom dom = null;
if (CallingType == null)
{
return(false);
}
dom = CallingType.SourceProjectDom;
IType b = dom.SearchType(CallingType.CompilationUnit, CallingType, CallingType.Location, baseType);
IType t = dom.SearchType(CallingType.CompilationUnit, CallingType, CallingType.Location, type);
if (b == null || t == null)
{
return(false);
}
return(dom.GetInheritanceTree(t).Any(tBase => tBase.DecoratedFullName == b.DecoratedFullName));
}
public GenerateNamespaceImport GetResult(ProjectDom dom, ICompilationUnit unit, IType type, TextEditorData data)
{
GenerateNamespaceImport result;
if (cache.TryGetValue(type.Namespace, out result))
{
return(result);
}
result = new GenerateNamespaceImport();
cache[type.Namespace] = result;
result.InsertNamespace = false;
DomLocation location = new DomLocation(data.Caret.Line, data.Caret.Column);
foreach (IUsing u in unit.Usings.Where(u => u.ValidRegion.Contains(location)))
{
if (u.Namespaces.Any(ns => type.Namespace == ns))
{
result.GenerateUsing = false;
return(result);
}
}
result.GenerateUsing = true;
string name = type.DecoratedFullName.Substring(type.Namespace.Length + 1);
foreach (IUsing u in unit.Usings.Where(u => u.ValidRegion.Contains(location)))
{
foreach (string ns in u.Namespaces)
{
if (dom.SearchType(unit, unit.GetTypeAt(location), location, ns + "." + name) != null)
{
result.GenerateUsing = false;
result.InsertNamespace = true;
return(result);
}
}
}
return(result);
}
// string expression;
/* IMember GetLanguageItem (Mono.TextEditor.Document document, LineSegment line, int offset, string expression)
* {
* string txt = document.Text;
* ExpressionResult expressionResult = new ExpressionResult (expression);
* // ExpressionResult expressionResult = expressionFinder.FindFullExpression (txt, offset);
* int lineNumber = document.OffsetToLineNumber (offset);
* expressionResult.Region = new DomRegion (lineNumber, offset - line.Offset, lineNumber, offset + expression.Length - line.Offset);
* expressionResult.ExpressionContext = ExpressionContext.IdentifierExpected;
*
* resolver = new NRefactoryResolver (ctx, doc.CompilationUnit, doc.TextEditor, document.FileName);
* ResolveResult result = resolver.Resolve (expressionResult, expressionResult.Region.Start);
*
* if (result is MemberResolveResult)
* return ((MemberResolveResult)result).ResolvedMember;
* return null;
* }*/
public override void Analyze(Mono.TextEditor.Document doc, LineSegment line, Chunk startChunk, int startOffset, int endOffset)
{
if (!MonoDevelop.Core.PropertyService.Get("EnableSemanticHighlighting", false) || doc == null || line == null || startChunk == null)
{
return;
}
ctx = GetParserContext(doc);
int lineNumber = doc.OffsetToLineNumber(line.Offset);
ParsedDocument parsedDocument = ProjectDomService.GetParsedDocument(ctx, doc.FileName);
ICompilationUnit unit = parsedDocument != null ? parsedDocument.CompilationUnit : null;
if (unit == null)
{
return;
}
for (Chunk chunk = startChunk; chunk != null; chunk = chunk.Next)
{
if (chunk.Style != "text")
{
continue;
}
for (int i = chunk.Offset; i < chunk.EndOffset; i++)
{
char charBefore = i > 0 ? doc.GetCharAt(i - 1) : '}';
if (Char.IsLetter(doc.GetCharAt(i)) && !Char.IsLetterOrDigit(charBefore))
{
}
else
{
continue;
}
int start = i;
bool wasWhitespace = false;
bool wasDot = false;
int bracketCount = 0;
while (start > 0)
{
char ch = doc.GetCharAt(start);
if (ch == '\n' || ch == '\r')
{
break;
}
if (wasWhitespace && IsNamePart(ch))
{
start++;
if (start < chunk.Offset)
{
start = Int32.MaxValue;
}
break;
}
if (ch == '<')
{
bracketCount--;
if (bracketCount < 0)
{
start++;
break;
}
start--;
wasWhitespace = false;
continue;
}
if (ch == '>')
{
if (wasWhitespace && !wasDot)
{
break;
}
bracketCount++;
start--;
wasWhitespace = false;
continue;
}
if (!IsNamePart(ch) && !Char.IsWhiteSpace(ch) && ch != '.')
{
start++;
break;
}
wasWhitespace = Char.IsWhiteSpace(ch);
wasDot = ch == '.' || wasDot && wasWhitespace;
start--;
}
int end = i;
int genericCount = 0;
wasWhitespace = false;
List <Segment> nameSegments = new List <Segment> ();
while (end < chunk.EndOffset)
{
char ch = doc.GetCharAt(end);
if (wasWhitespace && IsNamePart(ch))
{
break;
}
if (ch == '<')
{
genericCount = 1;
while (end < doc.Length)
{
ch = doc.GetCharAt(end);
if (ch == ',')
{
genericCount++;
}
if (ch == '>')
{
nameSegments.Add(new Segment(end, 1));
break;
}
end++;
}
break;
}
if (!IsNamePart(ch) && !Char.IsWhiteSpace(ch))
{
break;
}
wasWhitespace = Char.IsWhiteSpace(ch);
end++;
}
if (start >= end)
{
continue;
}
string typeString = doc.GetTextBetween(start, end);
IReturnType returnType = NRefactoryResolver.ParseReturnType(new ExpressionResult(typeString));
int nameEndOffset = start;
for (; nameEndOffset < end; nameEndOffset++)
{
char ch = doc.GetCharAt(nameEndOffset);
if (nameEndOffset >= i && ch == '<')
{
nameEndOffset++;
break;
}
}
nameSegments.Add(new Segment(i, nameEndOffset - i));
int column = i - line.Offset;
IType callingType = unit.GetTypeAt(lineNumber, column);
List <IReturnType> genericParams = null;
if (genericCount > 0)
{
genericParams = new List <IReturnType> ();
for (int n = 0; n < genericCount; n++)
{
genericParams.Add(new DomReturnType("A"));
}
}
IType type = null;
if (ctx != null)
{
type = ctx.SearchType((MonoDevelop.Projects.Dom.INode)callingType ?? unit, returnType);
}
if (type == null && unit != null && returnType != null)
{
type = unit.GetType(returnType.FullName, returnType.GenericArguments.Count);
}
if (ctx != null && type == null && returnType != null)
{
returnType.Name += "Attribute";
type = ctx.SearchType((MonoDevelop.Projects.Dom.INode)callingType ?? unit, returnType);
}
if (type != null)
{
nameSegments.ForEach(segment => HighlightSegment(startChunk, segment, "keyword.semantic.type"));
}
}
}
}
public IType SearchType(string fullyDecoratedName)
{
return(dom.SearchType(CallingMember ?? (MonoDevelop.Projects.Dom.INode)CallingType ?? Unit, fullyDecoratedName));
}
