public Candidate(IMethodOrProperty method)
{
if (method == null)
throw new ArgumentNullException("method");
this.Method = method;
this.OriginalMethod = method;
}
public static void AddContentsFromCalling(ArrayList result, IClass callingClass, IMember callingMember)
{
IMethodOrProperty methodOrProperty = callingMember as IMethodOrProperty;
if (methodOrProperty != null)
{
foreach (IParameter p in methodOrProperty.Parameters)
{
result.Add(new DefaultField.ParameterField(p.ReturnType, p.Name, methodOrProperty.Region, callingClass));
}
if (callingMember is IMethod)
{
AddTypeParametersForCtrlSpace(result, ((IMethod)callingMember).TypeParameters);
}
}
bool inStatic = false;
if (callingMember != null)
{
inStatic = callingMember.IsStatic;
}
if (callingClass != null)
{
AddTypeParametersForCtrlSpace(result, callingClass.TypeParameters);
ArrayList members = new ArrayList();
IReturnType t = callingClass.DefaultReturnType;
members.AddRange(t.GetMethods());
members.AddRange(t.GetFields());
members.AddRange(t.GetEvents());
members.AddRange(t.GetProperties());
foreach (IMember m in members)
{
if ((!inStatic || m.IsStatic) && m.IsAccessible(callingClass, true))
{
result.Add(m);
}
}
members.Clear();
IClass c = callingClass.DeclaringType;
while (c != null)
{
t = c.DefaultReturnType;
members.AddRange(t.GetMethods());
members.AddRange(t.GetFields());
members.AddRange(t.GetEvents());
members.AddRange(t.GetProperties());
c = c.DeclaringType;
}
foreach (IMember m in members)
{
if (m.IsStatic)
{
result.Add(m);
}
}
}
}
public static MethodMapping methodMapping(this O2MappedAstData astData, IMethodOrProperty iMethodOrProperty, INode iNode, string key)
{
string parentMethod = astData.parentMethodSignature(iNode);
string parentClass = astData.parentClassSignature(iNode);
return(astData.methodMapping(iMethodOrProperty.fullName(), key, parentMethod, parentClass, iNode));
}
static void TryAddExtension(LanguageProperties language, ArrayList res, IMethodOrProperty ext, IReturnType resolvedType)
{
// now add the extension method if it fits the type
if (MemberLookupHelper.IsApplicable(resolvedType, ext.Parameters[0].ReturnType, ext as IMethod))
{
IMethod method = ext as IMethod;
if (method != null && method.TypeParameters.Count > 0)
{
IReturnType[] typeArguments = new IReturnType[method.TypeParameters.Count];
MemberLookupHelper.InferTypeArgument(method.Parameters[0].ReturnType, resolvedType, typeArguments);
for (int i = 0; i < typeArguments.Length; i++)
{
if (typeArguments[i] != null)
{
ext = (IMethod)ext.CreateSpecializedMember();
ext.ReturnType = ConstructedReturnType.TranslateType(ext.ReturnType, typeArguments, true);
for (int j = 0; j < ext.Parameters.Count; ++j)
{
ext.Parameters[j].ReturnType = ConstructedReturnType.TranslateType(ext.Parameters[j].ReturnType, typeArguments, true);
}
break;
}
}
}
res.Add(ext);
}
}
void AddParameters(IMethodOrProperty target, ParameterDefinitionCollection plist)
{
foreach (ParameterDefinition par in plist)
{
IReturnType pReturnType = CreateType(this.ProjectContent, target, par.ParameterType);
DefaultParameter p = new DefaultParameter(par.Name, pReturnType, DomRegion.Empty);
if ((par.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out)
{
p.Modifiers = ParameterModifiers.Out;
}
else if (par.ParameterType is ReferenceType)
{
p.Modifiers = ParameterModifiers.Ref;
}
else
{
p.Modifiers = ParameterModifiers.In;
}
if ((par.Attributes & ParameterAttributes.Optional) == ParameterAttributes.Optional)
{
p.Modifiers |= ParameterModifiers.Optional;
}
if (p.ReturnType.IsArrayReturnType)
{
foreach (CustomAttribute att in par.CustomAttributes)
{
if (att.Constructor.DeclaringType.FullName == typeof(ParamArrayAttribute).FullName)
{
p.Modifiers |= ParameterModifiers.Params;
}
}
}
target.Parameters.Add(p);
}
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
IMethodOrProperty m = GetMethod(invocationExpression);
if (m == null)
{
// This might also be a delegate invocation:
// get the delegate's Invoke method
IReturnType targetType = invocationExpression.TargetObject.AcceptVisitor(this, data) as IReturnType;
if (targetType != null)
{
IClass c = targetType.GetUnderlyingClass();
if (c != null && c.ClassType == ClassType.Delegate)
{
// find the delegate's return type
m = c.Methods.Find(delegate(IMethod innerMethod) { return(innerMethod.Name == "Invoke"); });
}
}
}
if (m != null)
{
return(m.ReturnType);
}
else
{
return(null);
}
}
public static FilePosition GetEndPosition(this IMethodOrProperty method)
{
if (method.DeclaringTypeIsInterface())
{
return(method.Region.ToEndPosition(method.CompilationUnit));
}
return(method.BodyRegion.ToEndPosition(method.CompilationUnit));
}
public static string fullName(this IMethodOrProperty iMethodOrProperty)
{
if (iMethodOrProperty is IMethod)
return (iMethodOrProperty as IMethod).fullName();
else if (iMethodOrProperty is IProperty)
return (iMethodOrProperty as IProperty).fullName();
return "[null value]";
}
public Candidate(IMethodOrProperty method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
this.Method = method;
this.OriginalMethod = method;
}
public static bool HasTypeParameters(this IMethodOrProperty methodOrProperty)
{
var method = methodOrProperty as IMethod;
if ((method != null) && (method.TypeParameters != null))
{
return(method.TypeParameters.Count > 0);
}
return(false);
}
public static bool IsConstructor(this IMethodOrProperty methodOrProperty)
{
var method = methodOrProperty as IMethod;
if (method != null)
{
return(method.IsConstructor);
}
return(false);
}
public static void AddContentsFromCalling(List <ICompletionEntry> result, IClass callingClass, IMember callingMember)
{
IMethodOrProperty methodOrProperty = callingMember as IMethodOrProperty;
if (methodOrProperty != null)
{
foreach (IParameter p in methodOrProperty.Parameters)
{
result.Add(new DefaultField.ParameterField(p.ReturnType, p.Name, methodOrProperty.Region, callingClass));
}
if (callingMember is IMethod)
{
AddTypeParametersForCtrlSpace(result, ((IMethod)callingMember).TypeParameters);
}
}
bool inStatic = false;
if (callingMember != null)
{
inStatic = callingMember.IsStatic;
}
if (callingClass != null)
{
AddTypeParametersForCtrlSpace(result, callingClass.TypeParameters);
List <ICompletionEntry> members = new List <ICompletionEntry>();
IReturnType t = callingClass.DefaultReturnType;
var language = callingClass.ProjectContent.Language;
foreach (IMember m in MemberLookupHelper.GetAccessibleMembers(t, callingClass, language, true))
{
if ((!inStatic || m.IsStatic) && language.ShowMember(m, m.IsStatic))
{
result.Add(m);
}
}
members.Clear();
IClass c = callingClass.DeclaringType;
while (c != null)
{
t = c.DefaultReturnType;
foreach (IMember m in MemberLookupHelper.GetAccessibleMembers(t, c, language, true))
{
if (language.ShowMember(m, true))
{
result.Add(m);
}
}
c = c.DeclaringType;
}
}
}
public static string fullName(this IMethodOrProperty iMethodOrProperty)
{
if (iMethodOrProperty is IMethod)
{
return((iMethodOrProperty as IMethod).fullName());
}
else if (iMethodOrProperty is IProperty)
{
return((iMethodOrProperty as IProperty).fullName());
}
return("[null value]");
}
IInsightWindow ShowInsight(ITextEditor editor, IList <IInsightItem> insightItems, ICollection <ResolveResult> parameters, char charTyped)
{
int paramCount = parameters.Count;
if (insightItems == null || insightItems.Count == 0)
{
return(null);
}
bool overloadIsSure;
int defaultIndex;
if (insightItems.Count == 1)
{
overloadIsSure = true;
defaultIndex = 0;
}
else
{
var methods = insightItems.Select(item => GetMethodFromInsightItem(item)).ToList();
IReturnType[] argumentTypes = new IReturnType[paramCount + 1];
int i = 0;
foreach (ResolveResult rr in parameters)
{
if (rr != null)
{
argumentTypes[i] = rr.ResolvedType;
}
i++;
}
IMethodOrProperty result = OverloadResolution.FindOverload(methods.Where(m => m != null), argumentTypes, true, false, out overloadIsSure);
defaultIndex = methods.IndexOf(result);
}
IInsightWindow insightWindow = editor.ShowInsightWindow(insightItems);
if (insightWindow != null)
{
InitializeOpenedInsightWindow(editor, insightWindow);
insightWindow.SelectedItem = insightItems[defaultIndex];
}
if (overloadIsSure)
{
IMethodOrProperty method = GetMethodFromInsightItem(insightItems[defaultIndex]);
if (method != null && paramCount < method.Parameters.Count)
{
IParameter param = method.Parameters[paramCount];
ProvideContextCompletion(editor, param.ReturnType, charTyped);
}
}
return(insightWindow);
}
private NewEventHandlerCompletionItem GenerateCreateNewMember(IMethodOrProperty delegateSignature, ResolveResult resolveResult)
{
var parametersAsString = GenerateParametersString(DefaulAmbience, delegateSignature);
var callingClass = resolveResult.CallingClass;
var inStatic = false;
if (_resolveResult.CallingMember != null)
{
inStatic = _resolveResult.CallingMember.IsStatic;
}
var eventHandlerFullyQualifiedTypeName = FullyQualifiedAmbience.Convert(_resolvedReturnType);
var newHandlerName = BuildHandlerName();
if (newHandlerName == null)
{
var mrr = _resolveResult as MemberResolveResult;
var eventMember = (mrr != null ? mrr.ResolvedMember as IEvent : null);
newHandlerName =
((callingClass != null) ? callingClass.Name : "callingClass")
+ "_"
+ ((eventMember != null) ? eventMember.Name : "eventMember");
}
var newHandlerCodeBuilder = new StringBuilder();
newHandlerCodeBuilder.AppendLine().AppendLine();
if (inStatic)
{
newHandlerCodeBuilder.Append("static ");
}
newHandlerCodeBuilder
.Append(FullyQualifiedAmbience.Convert(delegateSignature.ReturnType)).Append(" ").Append(newHandlerName).Append("(")
.Append(parametersAsString).AppendLine(")")
.AppendLine("{")
.AppendLine("\t")
.Append("}");
var createNewMethod = new NewEventHandlerCompletionItem("generate " + newHandlerName + "(...);",
newHandlerName,
newHandlerName.Length,
newHandlerName.Length,
"new " + eventHandlerFullyQualifiedTypeName + "(" +
newHandlerName + ")\nGenerate new handler\n" +
CodeCompletionItem.GetDescription(_resolvedClass),
_resolveResult, newHandlerCodeBuilder.ToString());
return(createNewMethod);
}
static void TryAddExtension(LanguageProperties language, ArrayList res, IMethodOrProperty ext, IReturnType resolvedType)
{
// accept only extension methods
if (!ext.IsExtensionMethod)
{
return;
}
// don't add extension if method with that name already exists
// but allow overloading extension methods
foreach (IMember member in res)
{
IMethodOrProperty p = member as IMethodOrProperty;
if (p != null && p.IsExtensionMethod)
{
continue;
}
if (language.NameComparer.Equals(member.Name, ext.Name))
{
return;
}
}
// now add the extension method if it fits the type
if (MemberLookupHelper.ConversionExists(resolvedType, ext.Parameters[0].ReturnType))
{
IMethod method = ext as IMethod;
if (method != null && method.TypeParameters.Count > 0)
{
IReturnType[] typeArguments = new IReturnType[method.TypeParameters.Count];
MemberLookupHelper.InferTypeArgument(method.Parameters[0].ReturnType, resolvedType, typeArguments);
for (int i = 0; i < typeArguments.Length; i++)
{
if (typeArguments[i] != null)
{
ext = (IMethod)ext.Clone();
ext.ReturnType = ConstructedReturnType.TranslateType(ext.ReturnType, typeArguments, true);
for (int j = 0; j < ext.Parameters.Count; ++j)
{
ext.Parameters[j].ReturnType = ConstructedReturnType.TranslateType(ext.Parameters[j].ReturnType, typeArguments, true);
}
break;
}
}
}
res.Add(ext);
}
}
/// <summary>
/// For methods having a params-array as last parameter, expand the params array to
/// n parameters of the element type and add those as new candidates.
/// Mark candidates with the wrong parameter count as Status.WrongParameterCount.
/// </summary>
void ConstructExpandedForms()
{
LogStep("Step 1 (Construct expanded forms)");
foreach (Candidate candidate in candidates.ToArray())
{
if (candidate.Status == CandidateStatus.Success)
{
if (candidate.Parameters.Count > 0 && arguments.Count >= candidate.Parameters.Count - 1)
{
IParameter lastParameter = candidate.Parameters[candidate.Parameters.Count - 1];
if (lastParameter.IsParams && lastParameter.ReturnType.IsArrayReturnType)
{
// try to construct an expanded form with the correct parameter count
IReturnType elementType = lastParameter.ReturnType.CastToArrayReturnType().ArrayElementType;
IMethodOrProperty expanded = (IMethodOrProperty)candidate.Method.CreateSpecializedMember();
expanded.Parameters.RemoveAt(candidate.Parameters.Count - 1);
int index = 0;
while (expanded.Parameters.Count < arguments.Count)
{
expanded.Parameters.Add(new DefaultParameter(lastParameter.Name + (index++), elementType, lastParameter.Region));
}
candidates.Add(new Candidate(expanded)
{
IsExpanded = true,
OriginalMethod = candidate.Method
});
}
}
if (allowAdditionalArguments)
{
if (candidate.Parameters.Count < arguments.Count)
{
candidate.Status = CandidateStatus.WrongParameterCount;
}
}
else
{
if (candidate.Parameters.Count != arguments.Count)
{
candidate.Status = CandidateStatus.WrongParameterCount;
}
}
}
}
}
IParameter SearchMethodParameter(string parameter)
{
IMethodOrProperty method = callingMember as IMethodOrProperty;
if (method == null)
{
return(null);
}
foreach (IParameter p in method.Parameters)
{
if (IsSameName(p.Name, parameter))
{
return(p);
}
}
return(null);
}
protected void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, ICollection <ResolveResult> parameters, char charTyped)
{
int paramCount = parameters.Count;
dp.SetupDataProvider(editor.FileName, editor.ActiveTextAreaControl.TextArea);
List <IMethodOrProperty> methods = dp.Methods;
if (methods.Count == 0)
{
return;
}
bool overloadIsSure;
if (methods.Count == 1)
{
overloadIsSure = true;
dp.DefaultIndex = 0;
}
else
{
IReturnType[] argumentTypes = new IReturnType[paramCount + 1];
int i = 0;
foreach (ResolveResult rr in parameters)
{
if (rr != null)
{
argumentTypes[i] = rr.ResolvedType;
}
i++;
}
IMethodOrProperty result = Dom.CSharp.OverloadResolution.FindOverload(
methods, argumentTypes, true, false, out overloadIsSure);
dp.DefaultIndex = methods.IndexOf(result);
}
editor.ShowInsightWindow(dp);
if (overloadIsSure)
{
IMethodOrProperty method = methods[dp.DefaultIndex];
if (paramCount < method.Parameters.Count)
{
IParameter param = method.Parameters[paramCount];
ProvideContextCompletion(editor, param.ReturnType, charTyped);
}
}
}
static bool IsSimilarMemberInternal(IMember member1, IMember member2)
{
if (member1 == member2)
{
return(true);
}
if (member1 == null || member2 == null)
{
return(false);
}
if (member1.FullyQualifiedName != member2.FullyQualifiedName)
{
return(false);
}
if (member1.IsStatic != member2.IsStatic)
{
return(false);
}
IMethodOrProperty m1 = member1 as IMethodOrProperty;
IMethodOrProperty m2 = member2 as IMethodOrProperty;
if (m1 != null || m2 != null)
{
if (m1 != null && m2 != null)
{
if (DiffUtility.Compare(m1.Parameters, m2.Parameters) != 0)
{
return(false);
}
if (m1 is IMethod && m2 is IMethod)
{
if ((m1 as IMethod).TypeParameters.Count != (m2 as IMethod).TypeParameters.Count)
{
return(false);
}
}
}
else
{
return(false);
}
}
return(true);
}
IMethodOrProperty ResolveCurrentMember(IClass callingClass)
{
//LoggingService.DebugFormatted("Getting current method... caretLine = {0}, caretColumn = {1}", caretLine, caretColumn);
if (callingClass == null)
{
return(null);
}
IMethodOrProperty best = null;
int line = 0;
foreach (IMethod m in callingClass.Methods)
{
if (m.Region.BeginLine <= caretLine && m.Region.BeginLine > line)
{
line = m.Region.BeginLine;
best = m;
}
}
foreach (IProperty m in callingClass.Properties)
{
if (m.Region.BeginLine <= caretLine && m.Region.BeginLine > line)
{
line = m.Region.BeginLine;
best = m;
}
}
if (callingClass.Region.IsEmpty)
{
// maybe we are in Main method?
foreach (IMethod m in callingClass.Methods)
{
if (m.Region.IsEmpty && !m.IsSynthetic)
{
// the main method
if (best == null || best.BodyRegion.EndLine < caretLine)
{
return(m);
}
}
}
}
return(best);
}
bool Initialize(ParseInformation parseInfo, int caretLine, int caretColumn)
{
if (parseInfo == null)
{
return(false);
}
this.cu = parseInfo.MostRecentCompilationUnit;
if (cu == null)
{
return(false);
}
this.pc = cu.ProjectContent;
this.caretLine = caretLine;
this.caretColumn = caretColumn;
this.callingClass = GetCallingClass(pc);
callingMember = ResolveCurrentMember(callingClass);
if (callingMember == null)
{
if (cu != parseInfo.BestCompilationUnit)
{
IClass olderClass = GetCallingClass(parseInfo.BestCompilationUnit.ProjectContent);
if (olderClass != null && callingClass == null)
{
this.callingClass = olderClass;
}
callingMember = ResolveCurrentMember(olderClass);
}
}
if (callingMember != null)
{
if (caretLine > callingMember.BodyRegion.EndLine)
{
this.caretLine = callingMember.BodyRegion.EndLine;
this.caretColumn = callingMember.BodyRegion.EndColumn - 1;
}
else if (caretLine == callingMember.BodyRegion.EndLine && caretColumn >= callingMember.BodyRegion.EndColumn)
{
this.caretColumn = callingMember.BodyRegion.EndColumn - 1;
}
}
return(true);
}
protected void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, ICollection <ResolveResult> parameters, char charTyped)
{
int paramCount = parameters.Count;
dp.SetupDataProvider(editor.FileName, editor.ActiveTextAreaControl.TextArea);
List <IMethodOrProperty> methods = dp.Methods;
if (methods.Count == 0)
{
return;
}
bool overloadIsSure;
if (methods.Count == 1)
{
overloadIsSure = true;
dp.DefaultIndex = 0;
}
else
{
IReturnType[] parameterTypes = new IReturnType[paramCount + 1];
int i = 0;
foreach (ResolveResult rr in parameters)
{
if (rr != null)
{
parameterTypes[i] = rr.ResolvedType;
}
i++;
}
IReturnType[][] tmp;
int[] ranking = MemberLookupHelper.RankOverloads(methods, parameterTypes, true, out overloadIsSure, out tmp);
bool multipleBest = false;
int bestRanking = -1;
int best = 0;
for (i = 0; i < ranking.Length; i++)
{
if (ranking[i] > bestRanking)
{
bestRanking = ranking[i];
best = i;
multipleBest = false;
}
else if (ranking[i] == bestRanking)
{
multipleBest = true;
}
}
if (multipleBest)
{
overloadIsSure = false;
}
dp.DefaultIndex = best;
}
editor.ShowInsightWindow(dp);
if (overloadIsSure)
{
IMethodOrProperty method = methods[dp.DefaultIndex];
if (paramCount < method.Parameters.Count)
{
IParameter param = method.Parameters[paramCount];
ProvideContextCompletion(editor, param.ReturnType, charTyped);
}
}
}
void AddParameters(IMethodOrProperty target, Collection<ParameterDefinition> plist)
{
foreach (ParameterDefinition par in plist) {
IReturnType pReturnType = CreateType(this.ProjectContent, target, par.ParameterType);
DefaultParameter p = new DefaultParameter(par.Name, pReturnType, DomRegion.Empty);
if (par.ParameterType is ByReferenceType)
{
if ((par.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out) {
p.Modifiers = ParameterModifiers.Out;
} else {
p.Modifiers = ParameterModifiers.Ref;
}
} else {
p.Modifiers = ParameterModifiers.In;
}
if ((par.Attributes & ParameterAttributes.Optional) == ParameterAttributes.Optional) {
p.Modifiers |= ParameterModifiers.Optional;
}
if (p.ReturnType.IsArrayReturnType) {
foreach (CustomAttribute att in par.CustomAttributes) {
if (att.Constructor.DeclaringType.FullName == typeof(ParamArrayAttribute).FullName) {
p.Modifiers |= ParameterModifiers.Params;
}
}
}
target.Parameters.Add(p);
}
}
/// <summary>
/// Gets which function member is better. (§ 14.4.2.2)
/// </summary>
/// <param name="arguments">The arguments passed to the function</param>
/// <param name="m1">The first method</param>
/// <param name="parameters1">The expanded and substituted parameters of the first method</param>
/// <param name="m2">The second method</param>
/// <param name="parameters2">The expanded and substituted parameters of the second method</param>
/// <returns>0 if neither method is better. 1 if m1 is better. 2 if m2 is better.</returns>
static int GetBetterFunctionMember(IReturnType[] arguments,
IMethodOrProperty m1, IReturnType[] parameters1, bool isExpanded1,
IMethodOrProperty m2, IReturnType[] parameters2, bool isExpanded2)
{
int length = Math.Min(Math.Min(parameters1.Length, parameters2.Length), arguments.Length);
bool foundBetterParamIn1 = false;
bool foundBetterParamIn2 = false;
for (int i = 0; i < length; i++) {
if (arguments[i] == null)
continue;
int res = GetBetterConversion(arguments[i], parameters1[i], parameters2[i]);
if (res == 1) foundBetterParamIn1 = true;
if (res == 2) foundBetterParamIn2 = true;
}
if (foundBetterParamIn1 && !foundBetterParamIn2)
return 1;
if (foundBetterParamIn2 && !foundBetterParamIn1)
return 2;
if (foundBetterParamIn1 && foundBetterParamIn2)
return 0; // ambigous
// If none conversion is better than any other, it is possible that the
// expanded parameter lists are the same:
for (int i = 0; i < length; i++) {
if (!object.Equals(parameters1[i], parameters2[i])) {
// if expanded parameters are not the same, neither function member is better
return 0;
}
}
// the expanded parameters are the same, apply the tie-breaking rules from the spec:
// if one method is generic and the other non-generic, the non-generic is better
bool m1IsGeneric = (m1 is IMethod) ? ((IMethod)m1).TypeParameters.Count > 0 : false;
bool m2IsGeneric = (m2 is IMethod) ? ((IMethod)m2).TypeParameters.Count > 0 : false;
if (m1IsGeneric && !m2IsGeneric) return 2;
if (m2IsGeneric && !m1IsGeneric) return 1;
// for params parameters: non-expanded calls are better
if (isExpanded1 && !isExpanded2) return 2;
if (isExpanded2 && !isExpanded1) return 1;
// if the number of parameters is different, the one with more parameters is better
// this occurs when only when both methods are expanded
if (m1.Parameters.Count > m2.Parameters.Count) return 1;
if (m2.Parameters.Count > m1.Parameters.Count) return 2;
IReturnType[] m1ParamTypes = new IReturnType[m1.Parameters.Count];
IReturnType[] m2ParamTypes = new IReturnType[m2.Parameters.Count];
for (int i = 0; i < m1ParamTypes.Length; i++) {
m1ParamTypes[i] = m1.Parameters[i].ReturnType;
m2ParamTypes[i] = m2.Parameters[i].ReturnType;
}
return GetMoreSpecific(m1ParamTypes, m2ParamTypes);
}
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult)
{
string expression = expressionResult.Expression;
if (callingClass == null)
{
return(null);
}
int pos = expression.IndexOf('(');
if (pos >= 0)
{
expression = expression.Substring(0, pos);
}
expression = expression.Trim();
if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn) &&
callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name))
{
return(new TypeResolveResult(callingClass, callingMember, callingClass));
}
if (expressionResult.Context != ExpressionContext.Type)
{
if (callingMember != null &&
!callingMember.BodyRegion.IsInside(caretLine, caretColumn) &&
callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name))
{
return(new MemberResolveResult(callingClass, callingMember, callingMember));
}
}
return(null);
}
public Candidate(IMethodOrProperty method)
{
this.Method = method;
this.OriginalMethod = method;
}
public Candidate(IMethodOrProperty method)
{
this.Method = method;
this.OriginalMethod = method;
}
public static FilePosition GetStartPosition(this IMethodOrProperty method)
{
return(method.Region.ToStartPosition(method.CompilationUnit));
}
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult)
{
string expression = expressionResult.Expression;
if (expression == null) return null;
if (callingClass == null) return null;
int pos = expression.IndexOf('(');
if (pos >= 0) {
expression = expression.Substring(0, pos);
}
expression = expression.Trim();
// if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn)
// && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name))
// {
// return new TypeResolveResult(callingClass, callingMember, callingClass);
// }
if (expressionResult.Context != ExpressionContext.Type) {
if (callingMember != null
&& !callingMember.BodyRegion.IsInside(caretLine, caretColumn)
&& (callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name) ||
// For constructor definition, the expression is the constructor name (e.g. "MyClass") but the name of the member is "#ctor"
(callingMember.Name == "#ctor" && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name))
)
)
{
return new MemberResolveResult(callingClass, callingMember, callingMember);
}
}
return null;
}
internal static void AddParameters(AST.ParameterDeclarationCollection parameters, IList<IParameter> output, IMethodOrProperty method, IClass c)
{
if (c == null) throw new ArgumentNullException("c");
DefaultParameter p = null;
foreach (AST.ParameterDeclaration par in parameters) {
p = new DefaultParameter(par.Name,
CreateReturnType(par.Type, c, method as IMethod, c.Region.BeginLine + 1, 1, c.ProjectContent),
new DomRegion(par.LexicalInfo.Line, par.LexicalInfo.Column));
if (par.IsByRef) p.Modifiers |= ParameterModifiers.Ref;
output.Add(p);
}
if (parameters.HasParamArray) {
p.Modifiers |= ParameterModifiers.Params;
}
}
public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass,
IMethodOrProperty callingMember, int caretLine, int caretColumn,
IProjectContent projectContent)
{
System.Diagnostics.Debug.Assert(projectContent != null);
if (reference == null)
{
return(GetDefaultReturnType(projectContent));
}
if (reference is AST.ArrayTypeReference)
{
AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference;
return(new ArrayReturnType(projectContent,
CreateReturnType(arr.ElementType, callingClass, callingMember,
caretLine, caretColumn, projectContent),
(arr.Rank != null) ? (int)arr.Rank.Value : 1));
}
else if (reference is AST.SimpleTypeReference)
{
string name = ((AST.SimpleTypeReference)reference).Name;
IReturnType rt;
int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0;
if (name == "duck")
{
rt = new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType;
}
else if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name))
{
rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount);
}
else if (callingClass == null)
{
rt = new GetClassReturnType(projectContent, name, typeParameterCount);
}
else
{
rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn,
name, typeParameterCount);
}
if (typeParameterCount > 0)
{
AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments;
// GenericTypeReference derives from SimpleTypeReference
IReturnType[] typeArguments = new IReturnType[arguments.Count];
for (int i = 0; i < typeArguments.Length; i++)
{
typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn,
projectContent);
}
rt = new ConstructedReturnType(rt, typeArguments);
}
return(rt);
}
else if (reference is AST.CallableTypeReference)
{
AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference;
AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent));
if (ctr.ReturnType != null)
{
amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent);
}
amrt.MethodParameters = new List <IParameter>();
AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy"));
return(amrt);
}
else
{
throw new NotSupportedException("unknown reference type: " + reference.ToString());
}
}
public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass,
IMethodOrProperty callingMember, int caretLine, int caretColumn,
IProjectContent projectContent)
{
System.Diagnostics.Debug.Assert(projectContent != null);
if (reference == null) {
return GetDefaultReturnType(projectContent);
}
if (reference is AST.ArrayTypeReference) {
AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference;
return new ArrayReturnType(projectContent,
CreateReturnType(arr.ElementType, callingClass, callingMember,
caretLine, caretColumn, projectContent),
(arr.Rank != null) ? (int)arr.Rank.Value : 1);
} else if (reference is AST.SimpleTypeReference) {
string name = ((AST.SimpleTypeReference)reference).Name;
IReturnType rt;
int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0;
if (name == "duck")
rt = new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType;
else if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name))
rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount);
else if (callingClass == null)
rt = new GetClassReturnType(projectContent, name, typeParameterCount);
else
rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn,
name, typeParameterCount);
if (typeParameterCount > 0) {
AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments;
// GenericTypeReference derives from SimpleTypeReference
IReturnType[] typeArguments = new IReturnType[arguments.Count];
for (int i = 0; i < typeArguments.Length; i++) {
typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn,
projectContent);
}
rt = new ConstructedReturnType(rt, typeArguments);
}
return rt;
} else if (reference is AST.CallableTypeReference) {
AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference;
AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent));
if (ctr.ReturnType != null) {
amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent);
}
amrt.MethodParameters = new List<IParameter>();
AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy"));
return amrt;
} else {
throw new NotSupportedException("unknown reference type: " + reference.ToString());
}
}
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult)
{
try
{
string expression = expressionResult.Expression;
if (callingClass == null) return null;
int pos = expression.IndexOf('(');
if (pos >= 0)
{
expression = expression.Substring(0, pos);
}
expression = expression.Trim();
// if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn)
// && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name))
// {
// return new TypeResolveResult(callingClass, callingMember, callingClass);
// }
if (expressionResult.Context != ExpressionContext.Type)
{
if (callingMember != null
&& !callingMember.BodyRegion.IsInside(caretLine, caretColumn)
&& callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name))
{
return new MemberResolveResult(callingClass, callingMember, callingMember);
}
}
}
catch (Exception ex)
{
PublicDI.log.ex(ex, "in CtrlSpaceResolverHelper.GetResultFromDeclarationLine");
}
return null;
}
public static bool DeclaringTypeIsInterface(this IMethodOrProperty method)
{
return(method.DeclaringType.ClassType == ClassType.Interface);
}
public static MethodMapping methodMapping(this O2MappedAstData astData, IMethodOrProperty iMethodOrProperty, INode iNode, string key)
{
string parentMethod = astData.parentMethodSignature(iNode);
string parentClass = astData.parentClassSignature(iNode);
return astData.methodMapping(iMethodOrProperty.fullName(),key, parentMethod, parentClass, iNode);
}
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, string expression)
{
return(GetResultFromDeclarationLine(callingClass, callingMember, caretLine, caretColumn, new ExpressionResult(expression)));
}
bool Initialize(ParseInformation parseInfo, int caretLine, int caretColumn)
{
if (parseInfo == null) {
return false;
}
this.cu = parseInfo.CompilationUnit;
if (cu == null) {
return false;
}
this.pc = cu.ProjectContent;
this.caretLine = caretLine;
this.caretColumn = caretColumn;
this.callingClass = GetCallingClass(pc);
callingMember = ResolveCurrentMember(callingClass);
if (callingMember == null) {
if (cu != parseInfo.CompilationUnit) {
IClass olderClass = GetCallingClass(parseInfo.CompilationUnit.ProjectContent);
if (olderClass != null && callingClass == null) {
this.callingClass = olderClass;
}
callingMember = ResolveCurrentMember(olderClass);
}
}
if (callingMember != null) {
if (caretLine > callingMember.BodyRegion.EndLine) {
this.caretLine = callingMember.BodyRegion.EndLine;
this.caretColumn = callingMember.BodyRegion.EndColumn - 1;
} else if (caretLine == callingMember.BodyRegion.EndLine && caretColumn >= callingMember.BodyRegion.EndColumn) {
this.caretColumn = callingMember.BodyRegion.EndColumn - 1;
}
}
return true;
}
public CodeFunction(IMethod method, IDocumentLoader documentLoader)
: base(method)
{
this.method = method;
this.documentLoader = documentLoader;
}
static void TryAddExtension(LanguageProperties language, ArrayList res, IMethodOrProperty ext, IReturnType resolvedType)
{
// accept only extension methods
if (!ext.IsExtensionMethod)
return;
// don't add extension if method with that name already exists
// but allow overloading extension methods
foreach (IMember member in res) {
IMethodOrProperty p = member as IMethodOrProperty;
if (p != null && p.IsExtensionMethod)
continue;
if (language.NameComparer.Equals(member.Name, ext.Name)) {
return;
}
}
// now add the extension method if it fits the type
if (MemberLookupHelper.ConversionExists(resolvedType, ext.Parameters[0].ReturnType)) {
IMethod method = ext as IMethod;
if (method != null && method.TypeParameters.Count > 0) {
IReturnType[] typeArguments = new IReturnType[method.TypeParameters.Count];
MemberLookupHelper.InferTypeArgument(method.Parameters[0].ReturnType, resolvedType, typeArguments);
for (int i = 0; i < typeArguments.Length; i++) {
if (typeArguments[i] != null) {
ext = (IMethod)ext.Clone();
ext.ReturnType = ConstructedReturnType.TranslateType(ext.ReturnType, typeArguments, true);
for (int j = 0; j < ext.Parameters.Count; ++j) {
ext.Parameters[j].ReturnType = ConstructedReturnType.TranslateType(ext.Parameters[j].ReturnType, typeArguments, true);
}
break;
}
}
}
res.Add(ext);
}
}
public ResolveResult ResolveInternal(Expression expr, ExpressionContext context)
{
TypeVisitor typeVisitor = new TypeVisitor(this);
IReturnType type;
if (expr is PrimitiveExpression)
{
if (((PrimitiveExpression)expr).Value is int)
{
return(new IntegerLiteralResolveResult(callingClass, callingMember, projectContent.SystemTypes.Int32));
}
}
else if (expr is InvocationExpression)
{
IMethodOrProperty method = typeVisitor.GetMethod(expr as InvocationExpression);
if (method != null)
{
return(CreateMemberResolveResult(method));
}
else
{
// InvocationExpression can also be a delegate/event call
ResolveResult invocationTarget = ResolveInternal((expr as InvocationExpression).TargetObject, ExpressionContext.Default);
if (invocationTarget == null)
{
return(null);
}
type = invocationTarget.ResolvedType;
if (type == null)
{
return(null);
}
IClass c = type.GetUnderlyingClass();
if (c == null || c.ClassType != ClassType.Delegate)
{
return(null);
}
// We don't want to show "System.EventHandler.Invoke" in the tooltip
// of "EventCall(this, EventArgs.Empty)", we just show the event/delegate for now
// but for DelegateCall(params).* completion, we use the delegate's
// return type instead of the delegate type itself
method = c.Methods.Find(delegate(IMethod innerMethod) { return(innerMethod.Name == "Invoke"); });
if (method != null)
{
invocationTarget.ResolvedType = method.ReturnType;
}
return(invocationTarget);
}
}
else if (expr is IndexerExpression)
{
return(CreateMemberResolveResult(typeVisitor.GetIndexer(expr as IndexerExpression)));
}
else if (expr is FieldReferenceExpression)
{
FieldReferenceExpression fieldReferenceExpression = (FieldReferenceExpression)expr;
if (fieldReferenceExpression.FieldName == null || fieldReferenceExpression.FieldName.Length == 0)
{
// NRefactory creates this "dummy" fieldReferenceExpression when it should
// parse a primitive type name (int, short; Integer, Decimal)
if (fieldReferenceExpression.TargetObject is TypeReferenceExpression)
{
type = TypeVisitor.CreateReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference, this);
if (type != null)
{
return(new TypeResolveResult(callingClass, callingMember, type));
}
}
}
type = fieldReferenceExpression.TargetObject.AcceptVisitor(typeVisitor, null) as IReturnType;
if (type != null)
{
ResolveResult result = ResolveMemberReferenceExpression(type, fieldReferenceExpression);
if (result != null)
{
return(result);
}
}
}
else if (expr is IdentifierExpression)
{
ResolveResult result = ResolveIdentifier(((IdentifierExpression)expr).Identifier, context);
if (result != null)
{
return(result);
}
}
else if (expr is TypeReferenceExpression)
{
type = TypeVisitor.CreateReturnType(((TypeReferenceExpression)expr).TypeReference, this);
if (type != null)
{
if (type is TypeVisitor.NamespaceReturnType)
{
return(new NamespaceResolveResult(callingClass, callingMember, type.FullyQualifiedName));
}
IClass c = type.GetUnderlyingClass();
if (c != null)
{
return(new TypeResolveResult(callingClass, callingMember, type, c));
}
}
return(null);
}
type = expr.AcceptVisitor(typeVisitor, null) as IReturnType;
if (type == null || type.FullyQualifiedName == "")
{
return(null);
}
if (expr is ObjectCreateExpression)
{
List <IMethod> constructors = new List <IMethod>();
foreach (IMethod m in type.GetMethods())
{
if (m.IsConstructor && !m.IsStatic)
{
constructors.Add(m);
}
}
if (constructors.Count == 0)
{
// Class has no constructors -> create default constructor
IClass c = type.GetUnderlyingClass();
if (c != null)
{
return(CreateMemberResolveResult(Constructor.CreateDefault(c)));
}
}
IReturnType[] typeParameters = null;
if (type.IsConstructedReturnType)
{
typeParameters = new IReturnType[type.CastToConstructedReturnType().TypeArguments.Count];
type.CastToConstructedReturnType().TypeArguments.CopyTo(typeParameters, 0);
}
ResolveResult rr = CreateMemberResolveResult(typeVisitor.FindOverload(constructors, typeParameters, ((ObjectCreateExpression)expr).Parameters, null));
if (rr != null)
{
rr.ResolvedType = type;
}
return(rr);
}
return(new ResolveResult(callingClass, callingMember, type));
}
internal static void AddParameters(AST.ParameterDeclarationCollection parameters, IList <IParameter> output, IMethodOrProperty method, IClass c)
{
if (c == null)
{
throw new ArgumentNullException("c");
}
DefaultParameter p = null;
foreach (AST.ParameterDeclaration par in parameters)
{
p = new DefaultParameter(par.Name,
CreateReturnType(par.Type, c, method as IMethod, c.Region.BeginLine + 1, 1, c.ProjectContent),
new DomRegion(par.LexicalInfo.Line, par.LexicalInfo.Column));
if (par.IsByRef)
{
p.Modifiers |= ParameterModifiers.Ref;
}
output.Add(p);
}
if (parameters.HasParamArray)
{
p.Modifiers |= ParameterModifiers.Params;
}
}
