public static RemoveInfo GetRemoveInfo(TextEditor document, ref int pos)
{
int len = 0;
while (pos > 0 && IsWhiteSpace(document.GetCharAt(pos)))
{
--pos;
++len;
}
if (len > 0)
{
pos++;
return(new RemoveInfo(pos, len));
}
return(Empty);
}
internal static int GetCurrentParameterIndex(MonoDevelop.Ide.Gui.TextEditor editor, int offset, int memberStart)
{
int cursor = editor.CursorPosition;
int i = offset;
if (i > cursor)
{
return(-1);
}
if (i == cursor)
{
return(1);
}
int index = memberStart + 1;
int depth = 0;
do
{
char c = editor.GetCharAt(i - 1);
if (c == ',' && depth == 1)
{
index++;
}
if (c == '<')
{
depth++;
}
if (c == '>')
{
depth--;
}
i++;
} while (i <= cursor && depth > 0);
return(depth == 0 ? -1 : index);
}
public static string GetWhitespaces (TextEditor editor, int insertionOffset)
{
StringBuilder result = new StringBuilder ();
for (int i = insertionOffset; i < editor.Length; i++) {
char ch = editor.GetCharAt (i);
if (ch == ' ' || ch == '\t') {
result.Append (ch);
} else {
break;
}
}
return result.ToString ();
}
static int FindPrevWordStart (TextEditor editor, int offset)
{
while (--offset >= 0) {
var c = editor.GetCharAt (offset);
//Only legal characters in template Shortcut
//LetterOrDigit make sense
//_ to allow underscore naming convention
//# is because there are #if templates
//~ because disctructor template
//@ some Razor templates start with @
//in theory we should probably just support LetterOrDigit and _
if (!char.IsLetterOrDigit (c) && c != '_' && c != '#' && c != '~' && c != '@') {
break;
}
}
return ++offset;
}
static bool IsMatchAt (TextEditor editor, int offset, string abbrevWord)
{
if (offset + abbrevWord.Length >= editor.Length)
return false;
if (offset > 0 && IsIdentifierPart (editor.GetCharAt (offset - 1)))
return false;
if (offset + abbrevWord.Length < editor.Length && !IsIdentifierPart (editor.GetCharAt (offset + abbrevWord.Length)))
return false;
return editor.GetTextAt (offset, abbrevWord.Length) == abbrevWord;
}
static int SearchEndPos (int offset, TextEditor editor)
{
while (offset < editor.Length && IsIdentifierPart (editor.GetCharAt (offset))) {
offset++;
}
return offset;
}
static string GetWordBeforeCaret (TextEditor editor)
{
int startOffset = editor.CaretOffset;
int offset = startOffset - 1;
while (offset > 0) {
char ch = editor.GetCharAt (offset);
if (!IsIdentifierPart (ch)) {
offset++;
break;
}
offset--;
}
if (offset >= startOffset)
return "";
return editor.GetTextBetween (offset, startOffset);
}
public char GetCharAt(int position)
{
return(data.GetCharAt(position));
}
internal static int GetCurrentParameterIndex(MonoDevelop.Ide.Gui.TextEditor editor, int offset, int memberStart)
{
int cursor = editor.CursorPosition;
int i = offset;
if (i > cursor)
{
return(-1);
}
if (i == cursor)
{
return(1); // parameters are 1 based
}
IEnumerable <string> types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain(CSharpFormatter.MimeType);
CSharpIndentEngine engine = new CSharpIndentEngine(MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <CSharpFormattingPolicy> (types));
int index = memberStart + 1;
int parentheses = 0;
int bracket = 0;
do
{
char c = editor.GetCharAt(i - 1);
engine.Push(c);
switch (c)
{
case '{':
if (!engine.IsInsideOrdinaryCommentOrString)
{
bracket++;
}
break;
case '}':
if (!engine.IsInsideOrdinaryCommentOrString)
{
bracket--;
}
break;
case '(':
if (!engine.IsInsideOrdinaryCommentOrString)
{
parentheses++;
}
break;
case ')':
if (!engine.IsInsideOrdinaryCommentOrString)
{
parentheses--;
}
break;
case ',':
if (!engine.IsInsideOrdinaryCommentOrString && parentheses == 1 && bracket == 0)
{
index++;
}
break;
}
i++;
} while (i <= cursor && parentheses >= 0);
return(parentheses != 1 || bracket > 0 ? -1 : index);
}
public char GetCharAt(int position)
{
return(editor.GetCharAt(position));
}
static int SearchMatchingBracket (TextEditor editor, int offset, char openBracket, char closingBracket, int direction)
{
bool isInString = false;
bool isInChar = false;
bool isInBlockComment = false;
int depth = -1;
while (offset >= 0 && offset < editor.TextLength) {
char ch = editor.GetCharAt (offset);
switch (ch) {
case '/':
if (isInBlockComment)
isInBlockComment = editor.GetCharAt (offset + direction) != '*';
if (!isInString && !isInChar && offset - direction < editor.TextLength)
isInBlockComment = offset > 0 && editor.GetCharAt (offset - direction) == '*';
break;
case '"':
if (!isInChar && !isInBlockComment)
isInString = !isInString;
break;
case '\'':
if (!isInString && !isInBlockComment)
isInChar = !isInChar;
break;
default :
if (ch == closingBracket) {
if (!(isInString || isInChar || isInBlockComment))
--depth;
} else if (ch == openBracket) {
if (!(isInString || isInChar || isInBlockComment)) {
++depth;
if (depth == 0)
return offset;
}
}
break;
}
offset += direction;
}
return -1;
}
public ResolveResult ResolveIdentifier(ResolveVisitor visitor, string identifier)
{
ResolveResult result = null;
if (resultTable.TryGetValue(identifier, out result))
{
return(result);
}
resultTable[identifier] = result;
// Console.WriteLine (lookupVariableLine);
foreach (KeyValuePair <string, List <LocalLookupVariable> > pair in this.lookupTableVisitor.Variables)
{
if (identifier == pair.Key)
{
LocalLookupVariable var = null;
// Console.WriteLine ("--- RP:" + this.resolvePosition + "/" + pair.Value.Count);
foreach (LocalLookupVariable v2 in pair.Value)
{
DomLocation varStartPos = new DomLocation(lookupVariableLine + v2.StartPos.Line, v2.StartPos.Column - 1);
DomLocation varEndPos = new DomLocation(lookupVariableLine + v2.EndPos.Line, v2.EndPos.Column - 1);
// Console.WriteLine (v2.Name + ":" + varStartPos + " <> " + varEndPos + " resolve position:" + this.resolvePosition);
if (varStartPos > this.resolvePosition || (!v2.EndPos.IsEmpty && varEndPos < this.resolvePosition))
{
continue;
}
var = v2;
}
// Console.WriteLine ("var:" + var);
if (var == null)
{
continue;
}
IReturnType varType = null;
IReturnType varTypeUnresolved = null;
if (var.IsQueryContinuation)
{
QueryExpression query = var.Initializer as QueryExpression;
QueryExpressionGroupClause grouBy = query.SelectOrGroupClause as QueryExpressionGroupClause;
DomLocation old = resolvePosition;
try {
resolvePosition = new DomLocation(lookupVariableLine + grouBy.Projection.StartLocation.Line,
grouBy.Projection.StartLocation.Column);
ResolveResult initializerResolve = visitor.Resolve(grouBy.Projection);
ResolveResult groupByResolve = visitor.Resolve(grouBy.GroupBy);
DomReturnType resolved = new DomReturnType(dom.GetType("System.Linq.IGrouping", new IReturnType [] {
DomType.GetComponentType(dom, initializerResolve.ResolvedType), groupByResolve.ResolvedType
}));
varTypeUnresolved = varType = resolved;
} finally {
resolvePosition = old;
}
}
else if ((var.TypeRef == null || var.TypeRef.Type == "var" || var.TypeRef.IsNull))
{
if (var.ParentLambdaExpression != null)
{
ResolveResult lambdaResolve = ResolveLambda(visitor, var.ParentLambdaExpression);
if (lambdaResolve != null)
{
varType = lambdaResolve.ResolvedType;
varTypeUnresolved = lambdaResolve.UnresolvedType;
IType type = Dom.GetType(varType);
if (type != null && type.ClassType == MonoDevelop.Projects.Dom.ClassType.Delegate)
{
IMethod invocationMethod = type.Methods.First();
if (invocationMethod.Parameters.Count > 0)
{
varType = varTypeUnresolved = invocationMethod.Parameters[0].ReturnType;
}
}
}
else
{
varType = varTypeUnresolved = DomReturnType.Void;
}
}
if (var.Initializer != null)
{
ResolveResult initializerResolve = visitor.Resolve(var.Initializer);
// Console.WriteLine ("initializer : "+ var.Initializer + " result:" + initializerResolve);
varType = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.ResolvedType) : initializerResolve.ResolvedType;
varTypeUnresolved = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.UnresolvedType) : initializerResolve.UnresolvedType;
// Console.WriteLine ("resolved type:" + initializerResolve.ResolvedType + " is loop : " + var.IsLoopVariable);
// Console.WriteLine (varType);
// Console.WriteLine ("----------");
}
}
else
{
varTypeUnresolved = varType = ConvertTypeReference(var.TypeRef);
}
varType = ResolveType(varType);
result = new LocalVariableResolveResult(
new LocalVariable(CallingMember, identifier, varType,
new DomRegion(lookupVariableLine + var.StartPos.Line, var.StartPos.Column,
lookupVariableLine + var.StartPos.Line, var.EndPos.Column)),
var.IsLoopVariable);
result.ResolvedType = varType;
result.UnresolvedType = varTypeUnresolved;
goto end;
}
}
if (this.callingMember != null)
{
// special handling of property or field return types, they can have the same name as the return type
// ex.: MyType MyType { get; set; } Type1 Type1;
if ((callingMember is IProperty || callingMember is IField) && identifier == callingMember.Name)
{
int pos = editor.GetPositionFromLineColumn(resolvePosition.Line, resolvePosition.Column);
while (pos < editor.TextLength && !Char.IsWhiteSpace(editor.GetCharAt(pos)))
{
pos++;
}
while (pos < editor.TextLength && Char.IsWhiteSpace(editor.GetCharAt(pos)))
{
pos++;
}
StringBuilder memberName = new StringBuilder();
while (pos < editor.TextLength && (Char.IsLetterOrDigit(editor.GetCharAt(pos)) || editor.GetCharAt(pos) == '_'))
{
memberName.Append(editor.GetCharAt(pos));
pos++;
}
//Console.WriteLine ("id: '" + identifier + "' : '" + memberName.ToString () +"'" + (memberName.ToString () == identifier));
if (memberName.ToString() == identifier)
{
result = visitor.CreateResult(callingMember.ReturnType);
goto end;
}
}
if (identifier == "value" && this.callingMember is IProperty)
{
result = new MemberResolveResult(this.callingMember);
result.UnresolvedType = ((IProperty)this.callingMember).ReturnType;
result.ResolvedType = ResolveType(((IProperty)this.callingMember).ReturnType);
goto end;
}
if (this.callingMember is IMethod || this.callingMember is IProperty)
{
ReadOnlyCollection <IParameter> prms = this.callingMember is IMethod
? ((IMethod)this.callingMember).Parameters
: ((IProperty)this.callingMember).Parameters;
if (prms != null)
{
foreach (IParameter para in prms)
{
if (para.Name == identifier)
{
result = new ParameterResolveResult(para);
result.UnresolvedType = para.ReturnType;
result.ResolvedType = ResolveType(para.ReturnType);
goto end;
}
}
}
}
}
IType searchedType = SearchType(identifier);
if (this.callingType != null && dom != null)
{
List <IMember> members = new List <IMember> ();
foreach (IType type in dom.GetInheritanceTree(callingType))
{
members.AddRange(type.SearchMember(identifier, true));
}
bool includeProtected = true;
// filter members
if (this.CallingMember != null)
{
for (int i = 0; i < members.Count; i++)
{
if (this.CallingMember.IsStatic && !members[i].IsStatic ||
!members[i].IsAccessibleFrom(dom, callingType, this.CallingMember, includeProtected))
{
members.RemoveAt(i);
i--;
continue;
}
}
}
if (members.Count > 0)
{
if (members[0] is IMethod)
{
result = new MethodResolveResult(members);
if (CallingMember != null)
{
result.StaticResolve = CallingMember.IsStatic;
}
}
else if (members[0] is IType)
{
result = new MemberResolveResult(null, true);
result.UnresolvedType = result.ResolvedType = new DomReturnType((IType)members[0]);
goto end;
}
else
{
result = new MemberResolveResult(members[0]);
}
result.UnresolvedType = members[0].ReturnType;
result.ResolvedType = ResolveType(members[0].ReturnType);
if (members[0] is IProperty && searchedType != null && result.ResolvedType.FullName == searchedType.FullName)
{
result = new AggregatedResolveResult(result, new MemberResolveResult(null, true)
{
UnresolvedType = new DomReturnType(searchedType),
ResolvedType = new DomReturnType(searchedType)
});
}
goto end;
}
}
if (searchedType != null)
{
result = new MemberResolveResult(null, true);
result.UnresolvedType = result.ResolvedType = new DomReturnType(searchedType);
goto end;
}
if (dom.NamespaceExists(identifier, true))
{
result = new NamespaceResolveResult(identifier);
goto end;
}
if (unit != null && unit.Usings != null)
{
foreach (IUsing u in unit.Usings)
{
if (u.IsFromNamespace && u.Region.Contains(resolvePosition))
{
foreach (string ns in u.Namespaces)
{
if (dom.NamespaceExists(ns + "." + identifier, true))
{
result = new NamespaceResolveResult(ns + "." + identifier);
goto end;
}
}
}
foreach (KeyValuePair <string, IReturnType> alias in u.Aliases)
{
if (alias.Key == identifier || alias.Key + ".?" == identifier)
{
result = new NamespaceResolveResult(alias.Value.FullName);
goto end;
}
}
}
}
end:
if (result != null)
{
result.CallingType = CallingType;
result.CallingMember = CallingMember;
}
resultTable[identifier] = result;
return(result);
}
