public ElementReturnType(IProjectContent pc, IReturnType enumerableType)
{
if (pc == null)
throw new ArgumentNullException("pc");
this.enumerableType = enumerableType;
this.pc = pc;
}
void AddMethodsFromBaseType(List<IMethod> l, IReturnType baseType)
{
if (baseType != null) {
foreach (IMethod m in baseType.GetMethods()) {
if (m.IsConstructor)
continue;
bool ok = true;
if (m.IsOverridable) {
StringComparer comparer = m.DeclaringType.ProjectContent.Language.NameComparer;
foreach (IMethod oldMethod in c.Methods) {
if (comparer.Equals(oldMethod.Name, m.Name)) {
if (m.IsStatic == oldMethod.IsStatic && object.Equals(m.ReturnType, oldMethod.ReturnType)) {
if (DiffUtility.Compare(oldMethod.Parameters, m.Parameters) == 0) {
ok = false;
break;
}
}
}
}
}
if (ok)
l.Add(m);
}
}
}
public static IMethodOrProperty FindOverload(IEnumerable<IMethodOrProperty> list,
IReturnType[] arguments,
bool allowAdditionalArguments,
bool substituteInferredTypes,
out bool acceptableMatch)
{
OverloadResolution or = new OverloadResolution();
or.candidates = list.Select(m => new Candidate(m)).ToList();
or.arguments = arguments;
or.allowAdditionalArguments = allowAdditionalArguments;
if (or.candidates.Count == 0)
throw new ArgumentException("at least one candidate is required");
MemberLookupHelper.Log("OverloadResolution");
MemberLookupHelper.Log(" arguments = ", arguments);
or.ConstructExpandedForms();
or.InferTypeArguments();
or.CheckApplicability();
Candidate result = or.FindBestCandidate();
MemberLookupHelper.Log("Overload resolution finished. Winning candidate = " + result);
acceptableMatch = result.Status == CandidateStatus.Success;
if (substituteInferredTypes)
return result.Method;
else
return result.OriginalMethod;
}
ResolveResult CreateResolveResult(IReturnType resolvedType)
{
if (resolvedType == null)
return null;
else
return new ResolveResult(resolver.CallingClass, resolver.CallingMember, resolvedType);
}
public DefaultParameter(IParameter p)
{
this.name = p.Name;
this.region = p.Region;
this.modifier = p.Modifiers;
this.returnType = p.ReturnType;
}
protected bool ProvideContextCompletion(ITextEditor editor, IReturnType expected, char charTyped)
{
if (expected == null) return false;
IClass c = expected.GetUnderlyingClass();
if (c == null) return false;
if (c.ClassType == ClassType.Enum) {
CtrlSpaceCompletionItemProvider cdp = new NRefactoryCtrlSpaceCompletionItemProvider(languageProperties);
var ctrlSpaceList = cdp.GenerateCompletionList(editor);
if (ctrlSpaceList == null) return false;
ContextCompletionItemList contextList = new ContextCompletionItemList();
contextList.Items.AddRange(ctrlSpaceList.Items);
contextList.activationKey = charTyped;
foreach (CodeCompletionItem item in contextList.Items.OfType<CodeCompletionItem>()) {
IClass itemClass = item.Entity as IClass;
if (itemClass != null && c.FullyQualifiedName == itemClass.FullyQualifiedName && c.TypeParameters.Count == itemClass.TypeParameters.Count) {
contextList.SuggestedItem = item;
break;
}
}
if (contextList.SuggestedItem != null) {
if (charTyped != ' ') contextList.InsertSpace = true;
editor.ShowCompletionWindow(contextList);
return true;
}
}
return false;
}
void MakeTypeResult(IReturnType rt)
{
if (rt != null)
resolveResult = new TypeResolveResult(callingClass, resolver.CallingMember, rt);
else
ClearResult();
}
void MakeResult(IReturnType type)
{
if (type == null)
ClearResult();
else
resolveResult = new ResolveResult(callingClass, resolver.CallingMember, type);
}
public EventHandlerCompletitionDataProvider(string expression, ResolveResult resolveResult)
{
this.expression = expression;
this.resolveResult = resolveResult;
this.resolvedReturnType = resolveResult.ResolvedType;
this.resolvedClass = resolvedReturnType.GetUnderlyingClass();
}
public DefaultField(IReturnType type, string name, ModifierEnum m, DomRegion region, IClass declaringType)
: base(declaringType, name)
{
this.ReturnType = type;
this.Region = region;
this.Modifiers = m;
}
public DefaultMethod(string name, IReturnType type, ModifierEnum m, DomRegion region, DomRegion bodyRegion, IClass declaringType)
: base(declaringType, name)
{
this.ReturnType = type;
this.Region = region;
this.BodyRegion = bodyRegion;
Modifiers = m;
}
void AddWebViewPageBaseClass(DefaultClass webViewPageClass, IReturnType modelType)
{
IClass webViewPageBaseClass = webViewPageClass.ProjectContent.GetClass("System.Web.Mvc.WebViewPage", 1);
if (webViewPageBaseClass != null) {
IReturnType returnType = GetWebViewPageBaseClassReturnType(webViewPageBaseClass, modelType);
webViewPageClass.BaseTypes.Add(returnType);
}
}
public SharpAssemblyParameter(SharpAssembly_ asm, string paramName, IReturnType type)
{
name = paramName;
if (type.Name.EndsWith("&")) {
modifier |= ParameterModifier.Ref;
}
returnType = type;
}
/// <summary>
/// Returns null if base type is not an interface.
/// </summary>
public static CodeInterface CreateFromBaseType(IProjectContent projectContent, IReturnType baseType)
{
IClass baseTypeClass = baseType.GetUnderlyingClass();
if (baseTypeClass.ClassType == ClassType.Interface) {
return new CodeInterface(projectContent, baseType, baseTypeClass);
}
return null;
}
public DefaultAttribute(IReturnType attributeType, AttributeTarget attributeTarget, IList<object> positionalArguments, IDictionary<string, object> namedArguments)
{
if (attributeType == null)
throw new ArgumentNullException("attributeType");
this.AttributeType = attributeType;
this.AttributeTarget = attributeTarget;
this.positionalArguments = positionalArguments ?? new List<object>();
this.namedArguments = namedArguments ?? new SortedList<string, object>();
}
public ConstructedReturnType(IReturnType baseType, IList<IReturnType> typeArguments)
{
if (baseType == null)
throw new ArgumentNullException("baseType");
if (typeArguments == null)
throw new ArgumentNullException("typeArguments");
this.typeArguments = typeArguments;
this.baseType = baseType;
}
static NSObjectInfoService ()
{
string wrapperRootNamespace = "MonoTouch";
string foundation = wrapperRootNamespace + ".Foundation";
connectAttType = new DomReturnType (foundation, "ConnectAttribute");
exportAttType = new DomReturnType (foundation, "ExportAttribute");
registerAttType = new DomReturnType (foundation, "RegisterAttribute");
modelAttType = new DomReturnType (foundation, "ModelAttribute");
nsobjectType = new DomReturnType (foundation, "NSObject");
}
public static PersistentReturnType Resolve(IReturnType source, ITypeResolver typeResolver)
{
if (source == null) return null;
PersistentReturnType rt = new PersistentReturnType ();
rt.FullyQualifiedName = typeResolver.Resolve (source.FullyQualifiedName);
rt.pointerNestingLevel = source.PointerNestingLevel;
rt.arrayDimensions = source.ArrayDimensions;
return rt;
}
public DefaultEvent(string name, IReturnType type, ModifierEnum m, DomRegion region, DomRegion bodyRegion, IClass declaringType) : base(declaringType, name)
{
this.ReturnType = type;
this.Region = region;
this.BodyRegion = bodyRegion;
Modifiers = (ModifierEnum)m;
if (Modifiers == ModifierEnum.None) {
Modifiers = ModifierEnum.Private;
}
}
public virtual IEnumerable<string> ResolvePossibleNamespaces (IReturnType returnType)
{
foreach (string ns in InternalResolvePossibleNamespaces (returnType)) {
yield return ns;
}
foreach (ProjectDom refDom in References) {
foreach (string ns in refDom.InternalResolvePossibleNamespaces (returnType)) {
yield return ns;
}
}
}
protected virtual IEnumerable<string> InternalResolvePossibleNamespaces (IReturnType returnType)
{
if (returnType == null)
yield break;
foreach (IType type in Types) {
if (type.DecoratedFullName == type.Namespace + "." + returnType.DecoratedFullName) {
yield return type.Namespace;
}
}
}
public void CreateAttribute(string fullName, string shortName)
{
var returnTypeHelper = new ReturnTypeHelper();
returnTypeHelper.CreateReturnType(fullName);
returnTypeHelper.AddShortName(shortName);
AttributeType = returnTypeHelper.ReturnType;
Attribute = MockRepository.GenerateStub<IAttribute>();
Attribute.Stub(a => a.AttributeType).Return(AttributeType);
Attribute.Stub(a => a.PositionalArguments).Return(PositionalArguments);
Attribute.Stub(a => a.NamedArguments).Return(NamedArguments);
}
static bool CanCompareEqualityWithOperator(IReturnType type)
{
// return true for value types except float and double
// return false for reference types except string.
IClass c = type.GetUnderlyingClass();
return c != null
&& c.FullyQualifiedName != "System.Single"
&& c.FullyQualifiedName != "System.Double"
&& (c.ClassType == Dom.ClassType.Struct
|| c.ClassType == Dom.ClassType.Enum
|| c.FullyQualifiedName == "System.String");
}
public ArrayReturnType(IProjectContent pc, IReturnType elementType, int dimensions)
{
if (pc == null)
throw new ArgumentNullException("pc");
if (dimensions <= 0)
throw new ArgumentOutOfRangeException("dimensions", dimensions, "dimensions must be positive");
if (elementType == null)
throw new ArgumentNullException("elementType");
this.pc = pc;
this.elementType = elementType;
this.dimensions = dimensions;
}
public NSObjectInfoService (string wrapperRoot)
{
this.WrapperRoot = wrapperRoot;
string foundation = wrapperRoot + ".Foundation";
connectAttType = new DomReturnType (foundation, "ConnectAttribute");
exportAttType = new DomReturnType (foundation, "ExportAttribute");
iboutletAttType = new DomReturnType (foundation, "OutletAttribute");
ibactionAttType = new DomReturnType (foundation, "ActionAttribute");
registerAttType = new DomReturnType (foundation, "RegisterAttribute");
modelAttType = new DomReturnType (foundation, "ModelAttribute");
nsobjectType = new DomReturnType (foundation, "NSObject");
}
TypeResolveResult CreateTypeResolveResult(IReturnType resolvedType)
{
if (resolvedType == null) {
return null;
} else {
IReturnType rt = resolvedType;
while (rt != null && rt.IsArrayReturnType) {
rt = rt.CastToArrayReturnType().ArrayElementType;
}
IClass resolvedClass = rt != null ? rt.GetUnderlyingClass() : null;
return new TypeResolveResult(resolver.CallingClass, resolver.CallingMember, resolvedType, resolvedClass);
}
}
public override IReturnType ResolveReturnType(IReturnType[] parameterTypes)
{
if (lambdaExpression == null)
return ResolveReturnType();
try {
MemberLookupHelper.Log("LambdaReturnType: SetImplicitLambdaParameterTypes ", parameterTypes);
resolver.SetImplicitLambdaParameterTypes(lambdaExpression, parameterTypes);
return ResolveReturnType();
} finally {
resolver.UnsetImplicitLambdaParameterTypes(lambdaExpression);
}
}
/// <summary>
/// Assigns a ranking score to each method in the <paramref name="list"/>.
/// </summary>
/// <param name="list">Link with the methods to check.<br/>
/// <b>Generic methods in the input type are replaced by methods with have the types substituted!</b>
/// </param>
/// <param name="typeParameters">List with the type parameters passed to the method.
/// Can be null (=no type parameters)</param>
/// <param name="arguments">The types of the arguments passed to the method.
/// A null return type means any argument type is allowed.</param>
/// <param name="allowAdditionalArguments">Specifies whether the method can have
/// more parameters than specified here. Useful for method insight scenarios.</param>
/// <param name="acceptableMatch">Out parameter that is true when the best ranked
/// method is acceptable for a method call (no invalid casts)</param>
/// <returns>Integer array. Each value in the array </returns>
public static int[] RankOverloads(IList<IMethod> list,
IReturnType[] typeParameters,
IReturnType[] arguments,
bool allowAdditionalArguments,
out bool acceptableMatch)
{
acceptableMatch = false;
if (list.Count == 0) return new int[] {};
List<IMethodOrProperty> l2 = new List<IMethodOrProperty>(list.Count);
IReturnType[][] inferredTypeParameters;
// See ECMA-334, § 14.3
// If type parameters are specified, remove all methods from the list that do not
// use the specified number of parameters.
if (typeParameters != null && typeParameters.Length > 0) {
for (int i = 0; i < list.Count; i++) {
IMethod m = list[i];
if (m.TypeParameters.Count == typeParameters.Length) {
m = (IMethod)m.Clone();
m.ReturnType = ConstructedReturnType.TranslateType(m.ReturnType, typeParameters, true);
for (int j = 0; j < m.Parameters.Count; ++j) {
m.Parameters[j].ReturnType = ConstructedReturnType.TranslateType(m.Parameters[j].ReturnType, typeParameters, true);
}
list[i] = m;
l2.Add(m);
}
}
int[] innerRanking = RankOverloads(l2, arguments, allowAdditionalArguments, out acceptableMatch, out inferredTypeParameters);
int[] ranking = new int[list.Count];
int innerIndex = 0;
for (int i = 0; i < ranking.Length; i++) {
if (list[i].TypeParameters.Count == typeParameters.Length) {
ranking[i] = innerRanking[innerIndex++];
} else {
ranking[i] = 0;
}
}
return ranking;
} else {
// Note that when there are no type parameters, methods having type parameters
// are not removed, since the type inference process might be able to infer the
// type arguments.
foreach (IMethod m in list) l2.Add(m);
int[] ranking = RankOverloads(l2, arguments, allowAdditionalArguments, out acceptableMatch, out inferredTypeParameters);
ApplyInferredTypeParameters(list, inferredTypeParameters);
return ranking;
}
}
public static IMethod FindOverload(IList<IMethod> methods, IReturnType[] typeParameters, IReturnType[] arguments)
{
if (methods.Count == 0)
return null;
bool tmp;
int[] ranking = RankOverloads(methods, typeParameters, arguments, false, out tmp);
int bestRanking = -1;
int best = 0;
for (int i = 0; i < ranking.Length; i++) {
if (ranking[i] > bestRanking) {
bestRanking = ranking[i];
best = i;
}
}
return methods[best];
}
/// <summary>
/// Gets whether this type parameter occurs in the specified return type.
/// </summary>
public bool OccursIn(IReturnType rt)
{
ArrayReturnType art = rt.CastToArrayReturnType();
if (art != null) {
return OccursIn(art.ArrayElementType);
}
ConstructedReturnType crt = rt.CastToConstructedReturnType();
if (crt != null) {
return crt.TypeArguments.Any(ta => OccursIn(ta));
}
GenericReturnType grt = rt.CastToGenericReturnType();
if (grt != null) {
return this.TypeParameter.Equals(grt.TypeParameter);
}
return false;
}
public virtual IType SearchType(ICompilationUnit unit, IType callingClass, DomLocation lookupLocation, IReturnType returnType)
{
if (returnType == null)
{
return(null);
}
return(SearchType(unit, callingClass, lookupLocation, returnType.DecoratedFullName, returnType.GenericArguments));
}
IType SearchType(IUsing iusing, string partitialTypeName, IList <IReturnType> genericArguments, bool caseSensitive)
{
IType c = GetType(partitialTypeName, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
foreach (string str in iusing.Namespaces)
{
string possibleType = String.Concat(str, ".", partitialTypeName);
c = GetType(possibleType, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
}
IReturnType alias;
// search class in partial namespaces
if (iusing.Aliases.TryGetValue("", out alias))
{
string declaringNamespace = alias.FullName;
while (declaringNamespace.Length > 0)
{
string className = String.Concat(declaringNamespace, ".", partitialTypeName);
c = GetType(className, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
int index = declaringNamespace.IndexOf('.');
if (index > 0)
{
declaringNamespace = declaringNamespace.Substring(0, index);
}
else
{
break;
}
}
}
foreach (string aliasString in iusing.Aliases.Keys)
{
if (caseSensitive ? partitialTypeName.StartsWith(aliasString) : partitialTypeName.ToLower().StartsWith(aliasString.ToLower()))
{
string className = null;
if (aliasString.Length > 0)
{
IReturnType rt = iusing.Aliases [aliasString];
className = String.Concat(rt.FullName, partitialTypeName.Remove(0, aliasString.Length));
c = GetType(className, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
}
}
}
return(null);
}
/// <summary>
/// Gets all types the specified type inherits from (all classes and interfaces).
/// Unlike the class inheritance tree, this method takes care of type arguments and calculates the type
/// arguments that are passed to base classes.
/// </summary>
public static IEnumerable <IReturnType> GetTypeInheritanceTree(IReturnType typeToListInheritanceTreeFor)
{
if (typeToListInheritanceTreeFor == null)
{
throw new ArgumentNullException("typeToListInheritanceTreeFor");
}
lock (getTypeInheritanceTreeCache) {
IEnumerable <IReturnType> result;
if (getTypeInheritanceTreeCache.TryGetValue(typeToListInheritanceTreeFor, out result))
{
return(result);
}
}
IClass classToListInheritanceTreeFor = typeToListInheritanceTreeFor.GetUnderlyingClass();
if (classToListInheritanceTreeFor == null)
{
return new IReturnType[] { typeToListInheritanceTreeFor }
}
;
if (typeToListInheritanceTreeFor.IsArrayReturnType)
{
IReturnType elementType = typeToListInheritanceTreeFor.CastToArrayReturnType().ArrayElementType;
List <IReturnType> resultList = new List <IReturnType>();
resultList.Add(typeToListInheritanceTreeFor);
resultList.AddRange(GetTypeInheritanceTree(
new ConstructedReturnType(
classToListInheritanceTreeFor.ProjectContent.GetClass("System.Collections.Generic.IList", 1).DefaultReturnType,
new IReturnType[] { elementType }
)
));
resultList.Add(classToListInheritanceTreeFor.ProjectContent.GetClass("System.Collections.IList", 0).DefaultReturnType);
resultList.Add(classToListInheritanceTreeFor.ProjectContent.GetClass("System.Collections.ICollection", 0).DefaultReturnType);
// non-generic IEnumerable is already added by generic IEnumerable
return(resultList);
}
HashSet <IReturnType> visitedSet = new HashSet <IReturnType>();
List <IReturnType> visitedList = new List <IReturnType>();
Queue <IReturnType> typesToVisit = new Queue <IReturnType>();
bool enqueuedLastBaseType = false;
IReturnType currentType = typeToListInheritanceTreeFor;
IClass currentClass = classToListInheritanceTreeFor;
IReturnType nextType;
do
{
if (currentClass != null)
{
if (visitedSet.Add(currentType))
{
visitedList.Add(currentType);
foreach (IReturnType type in currentClass.BaseTypes)
{
typesToVisit.Enqueue(TranslateIfRequired(currentType, type));
}
}
}
if (typesToVisit.Count > 0)
{
nextType = typesToVisit.Dequeue();
}
else
{
nextType = enqueuedLastBaseType ? null : DefaultClass.GetBaseTypeByClassType(classToListInheritanceTreeFor);
enqueuedLastBaseType = true;
}
if (nextType != null)
{
currentType = nextType;
currentClass = nextType.GetUnderlyingClass();
}
} while (nextType != null);
lock (getTypeInheritanceTreeCache) {
if (getTypeInheritanceTreeCache.Count == 0)
{
DomCache.RegisterForClear(ClearGetTypeInheritanceTreeCache);
}
getTypeInheritanceTreeCache[typeToListInheritanceTreeFor] = visitedList;
}
return(visitedList);
}
public override object VisitTypeDeclaration(NRefactoryAST.TypeDeclaration typeDeclaration, object data)
{
DomRegion region = GetRegion(typeDeclaration.StartLocation, typeDeclaration.EndLocation);
DomRegion bodyRegion = GetRegion(typeDeclaration.BodyStartLocation, typeDeclaration.EndLocation);
DefaultClass c = new DefaultClass(cu, TranslateClassType(typeDeclaration.Type), ConvertTypeModifier(typeDeclaration.Modifier), region, GetCurrentClass());
if (c.IsStatic)
{
// static classes are also abstract and sealed at the same time
c.Modifiers |= ModifierEnum.Abstract | ModifierEnum.Sealed;
}
c.BodyRegion = bodyRegion;
ConvertAttributes(typeDeclaration, c);
c.Documentation = GetDocumentation(region.BeginLine, typeDeclaration.Attributes);
DefaultClass outerClass = GetCurrentClass();
if (outerClass != null)
{
outerClass.InnerClasses.Add(c);
c.FullyQualifiedName = outerClass.FullyQualifiedName + '.' + typeDeclaration.Name;
}
else
{
c.FullyQualifiedName = PrependCurrentNamespace(typeDeclaration.Name);
cu.Classes.Add(c);
}
c.UsingScope = currentNamespace;
currentClass.Push(c);
ConvertTemplates(outerClass, typeDeclaration.Templates, c); // resolve constrains in context of the class
// templates must be converted before base types because base types may refer to generic types
if (c.ClassType != ClassType.Enum && typeDeclaration.BaseTypes != null)
{
foreach (NRefactoryAST.TypeReference type in typeDeclaration.BaseTypes)
{
IReturnType rt = CreateReturnType(type, null, TypeVisitor.ReturnTypeOptions.BaseTypeReference);
if (rt != null)
{
c.BaseTypes.Add(rt);
}
}
}
object ret = typeDeclaration.AcceptChildren(this, data);
currentClass.Pop();
if (c.ClassType == ClassType.Module)
{
foreach (DefaultField f in c.Fields)
{
f.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultMethod m in c.Methods)
{
m.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultProperty p in c.Properties)
{
p.Modifiers |= ModifierEnum.Static;
}
foreach (DefaultEvent e in c.Events)
{
e.Modifiers |= ModifierEnum.Static;
}
}
mapType(typeDeclaration, c);
return(ret);
}
public override bool Equals(IReturnType o)
{
return(o is NullReturnType);
}
/// <remarks>
/// does the dynamic lookup for the typeName
/// </remarks>
public IReturnType DynamicLookup(string typeName)
{
// Console.WriteLine("starting dynamic lookup");
// Console.WriteLine("name == " + typeName);
// try if it exists a variable named typeName
ReturnType variable = SearchVariable(typeName);
if (variable != null)
{
showStatic = false;
return(variable);
}
// Console.WriteLine("No Variable found");
if (callingClass == null)
{
return(null);
}
//// somehow search in callingClass fields is not returning anything, so I am searching here once again
foreach (IField f in callingClass.Fields)
{
if (f.Name == typeName)
{
// Console.WriteLine("Field found " + f.Name);
return(f.ReturnType);
}
}
//// end of mod for search in Fields
// try if typeName is a method parameter
IReturnType p = SearchMethodParameter(typeName);
if (p != null)
{
// Console.WriteLine("MethodParameter Found");
showStatic = false;
return(p);
}
// Console.WriteLine("No Parameter found");
// check if typeName == value in set method of a property
if (typeName == "value")
{
p = SearchProperty();
if (p != null)
{
showStatic = false;
return(p);
}
}
// Console.WriteLine("No Property found");
// try if there exists a nonstatic member named typeName
showStatic = false;
IReturnType t = SearchMember(callingClass == null ? null : new ReturnType(callingClass.FullyQualifiedName), typeName);
if (t != null)
{
return(t);
}
// Console.WriteLine("No nonstatic member found");
// try if there exists a static member named typeName
showStatic = true;
t = SearchMember(callingClass == null ? null : new ReturnType(callingClass.FullyQualifiedName), typeName);
if (t != null)
{
showStatic = false;
return(t);
}
// Console.WriteLine("No static member found");
// try if there exists a static member in outer classes named typeName
ClassCollection classes = GetOuterClasses();
foreach (IClass c in GetOuterClasses())
{
t = SearchMember(callingClass == null ? null : new ReturnType(c.FullyQualifiedName), typeName);
if (t != null)
{
showStatic = false;
return(t);
}
}
// Console.WriteLine("No static member in outer classes found");
// Console.WriteLine("DynamicLookUp resultless");
return(null);
}
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (resolver.Language == SupportedLanguage.CSharp && resolver.CallingClass != null)
{
if (invocationExpression.TargetObject is ThisReferenceExpression)
{
// call to constructor
return(ResolveConstructorOverload(resolver.CallingClass, invocationExpression.Arguments));
}
else if (invocationExpression.TargetObject is BaseReferenceExpression)
{
return(ResolveConstructorOverload(resolver.CallingClass.BaseType, invocationExpression.Arguments));
}
}
ResolveResult rr = Resolve(invocationExpression.TargetObject);
MixedResolveResult mixedRR = rr as MixedResolveResult;
if (mixedRR != null)
{
rr = mixedRR.PrimaryResult;
}
MethodGroupResolveResult mgrr = rr as MethodGroupResolveResult;
if (mgrr != null)
{
if (resolver.Language == SupportedLanguage.VBNet && mgrr.Methods.All(mg => mg.Count == 0))
{
return(CreateMemberResolveResult(GetVisualBasicIndexer(invocationExpression)));
}
IReturnType[] argumentTypes = invocationExpression.Arguments.Select <Expression, IReturnType>(ResolveType).ToArray();
MemberResolveResult firstResult = null;
foreach (MethodGroup methodGroup in mgrr.Methods)
{
bool resultIsAcceptable;
IMethod method;
if (methodGroup.IsExtensionMethodGroup)
{
IReturnType[] extendedTypes = new IReturnType[argumentTypes.Length + 1];
extendedTypes[0] = mgrr.ContainingType;
argumentTypes.CopyTo(extendedTypes, 1);
method = MemberLookupHelper.FindOverload(methodGroup, extendedTypes, out resultIsAcceptable);
}
else
{
method = MemberLookupHelper.FindOverload(methodGroup, argumentTypes, out resultIsAcceptable);
}
MemberResolveResult result = CreateMemberResolveResult(method);
if (result != null && methodGroup.IsExtensionMethodGroup)
{
result.IsExtensionMethodCall = true;
}
if (resultIsAcceptable)
{
return(result);
}
if (firstResult == null)
{
firstResult = result;
}
}
if (firstResult != null)
{
return(firstResult);
}
else
{
return(FallbackResolveMethod(invocationExpression, mgrr, argumentTypes));
}
}
else if (rr != null && rr.ResolvedType != null)
{
IClass c = rr.ResolvedType.GetUnderlyingClass();
if (c != null && c.ClassType == ClassType.Delegate)
{
// 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
IMethod method = rr.ResolvedType.GetMethods().FirstOrDefault(innerMethod => innerMethod.Name == "Invoke");
if (method != null)
{
return(new DelegateCallResolveResult(rr, method));
}
}
}
if (resolver.Language == SupportedLanguage.VBNet)
{
return(CreateMemberResolveResult(GetVisualBasicIndexer(invocationExpression)));
}
return(null);
}
bool IsApplicable(IReturnType argument, IReturnType expected)
{
return(MemberLookupHelper.IsApplicable(argument, expected, methodForGenericCalls));
}
protected TypeReference ConvertType(IReturnType type)
{
return(CodeGenerator.ConvertType(type, classFinderContext));
}
public void Add(string name, IReturnType type)
{
typeTable.Add(name, type);
}
public static DomType CreateDelegate(ICompilationUnit compilationUnit, string name, DomLocation location, IReturnType type, IEnumerable <IParameter> parameters)
{
DomType result = new DomType();
result.compilationUnit = compilationUnit;
result.Name = name;
result.classType = MonoDevelop.Projects.Dom.ClassType.Delegate;
DomMethod delegateMethod = new DomMethod("Invoke", Modifiers.None, MethodModifier.None, location, DomRegion.Empty, type);
delegateMethod.Add(parameters);
result.Add(delegateMethod);
return(result);
}
public static ICSharpCode.NRefactory.CSharp.AstType ShortenTypeName(MonoDevelop.Ide.Gui.Document doc, IReturnType fullyQualifiedTypeName)
{
return(doc.ParsedDocument.CompilationUnit.ShortenTypeName(fullyQualifiedTypeName, doc.Editor.Caret.Line, doc.Editor.Caret.Column).ConvertToTypeReference());
}
public override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
{
IReturnType left = GetTypeSafe(binaryOperatorExpression.Left);
IReturnType right = GetTypeSafe(binaryOperatorExpression.Right);
string opName = GetOperatorName(binaryOperatorExpression.Op);
if (!String.IsNullOrEmpty(opName))
{
IType leftType = this.resolver.Dom.GetType(left);
int leftOperatorLevel = 0;
IMethod leftOperator = leftType != null?FindOperator(leftType, opName, out leftOperatorLevel) : null;
IType rightType = this.resolver.Dom.GetType(right);
int rightOperatorLevel = 0;
IMethod rightOperator = rightType != null?FindOperator(rightType, opName, out rightOperatorLevel) : null;
if (leftOperator != null && rightOperator != null)
{
if (leftOperatorLevel < rightOperatorLevel)
{
return(CreateResult(leftOperator.ReturnType));
}
return(CreateResult(rightOperator.ReturnType));
}
if (leftOperator != null)
{
return(CreateResult(leftOperator.ReturnType));
}
if (rightOperator != null)
{
return(CreateResult(rightOperator.ReturnType));
}
}
switch (binaryOperatorExpression.Op)
{
case BinaryOperatorType.Equality:
case BinaryOperatorType.InEquality:
case BinaryOperatorType.ReferenceEquality:
case BinaryOperatorType.ReferenceInequality:
case BinaryOperatorType.LogicalAnd:
case BinaryOperatorType.LogicalOr:
case BinaryOperatorType.LessThan:
case BinaryOperatorType.LessThanOrEqual:
case BinaryOperatorType.GreaterThan:
case BinaryOperatorType.GreaterThanOrEqual:
return(CreateResult(typeof(bool).FullName));
case BinaryOperatorType.NullCoalescing:
return(Resolve(binaryOperatorExpression.Left));
// vb operators
case BinaryOperatorType.DivideInteger:
return(CreateResult(typeof(int).FullName));
case BinaryOperatorType.Concat:
return(CreateResult(typeof(string).FullName));
default:
return(CreateResult(GetCommonType(left,
right).FullName));
}
}
/// <summary>
/// Gets which function member is better. (§ 14.4.2.2)
/// </summary>
/// <returns>0 if neither method is better. 1 if c1 is better. 2 if c2 is better.</returns>
int GetBetterFunctionMember(Candidate c1, Candidate c2)
{
int length = Math.Min(Math.Min(c1.Parameters.Count, c2.Parameters.Count), arguments.Count);
bool foundBetterParamIn1 = false;
bool foundBetterParamIn2 = false;
for (int i = 0; i < length; i++)
{
if (arguments[i] == null)
{
continue;
}
int res = MemberLookupHelper.GetBetterConversion(arguments[i], c1.Parameters[i].ReturnType, c2.Parameters[i].ReturnType);
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(c1.Parameters[i].ReturnType, c2.Parameters[i].ReturnType))
{
// 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 = c1.TypeParameterCount > 0;
bool m2IsGeneric = c2.TypeParameterCount > 0;
if (m1IsGeneric && !m2IsGeneric)
{
return(2);
}
if (m2IsGeneric && !m1IsGeneric)
{
return(1);
}
// for params parameters: non-expanded calls are better
if (c1.IsExpanded && !c2.IsExpanded)
{
return(2);
}
if (c2.IsExpanded && !c1.IsExpanded)
{
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 (c1.OriginalMethod.Parameters.Count > c2.OriginalMethod.Parameters.Count)
{
return(1);
}
if (c2.OriginalMethod.Parameters.Count > c1.OriginalMethod.Parameters.Count)
{
return(2);
}
IReturnType[] m1ParamTypes = new IReturnType[c1.Parameters.Count];
IReturnType[] m2ParamTypes = new IReturnType[c2.Parameters.Count];
for (int i = 0; i < m1ParamTypes.Length; i++)
{
m1ParamTypes[i] = c1.Parameters[i].ReturnType;
m2ParamTypes[i] = c2.Parameters[i].ReturnType;
}
return(GetMoreSpecific(m1ParamTypes, m2ParamTypes));
}
public static bool Equals(IReturnType rt1, IReturnType rt2)
{
return(rt1.FullyQualifiedName == rt2.FullyQualifiedName && rt1.TypeParameterCount == rt2.TypeParameterCount);
}
ConstructedReturnType EnumerableOf(IReturnType element)
{
return(new ConstructedReturnType(EnumerableClass.DefaultReturnType, new IReturnType[] { element }));
}
public ResolveResult Resolve(IParserContext parserService, string expression, int caretLineNumber, int caretColumn, string fileName, string fileContent)
{
Console.WriteLine("Start Resolving");
if (expression == null)
{
return(null);
}
expression = expression.TrimStart(null);
if (expression == "")
{
return(null);
}
if (expression.StartsWith("using "))
{
// expression[expression.Length - 1] != '.'
// the period that causes this Resove() is not part of the expression
if (expression[expression.Length - 1] == '.')
{
return(null);
}
int i;
for (i = expression.Length - 1; i >= 0; --i)
{
if (!(Char.IsLetterOrDigit(expression[i]) || expression[i] == '_' || expression[i] == '.'))
{
break;
}
}
// no Identifier before the period
if (i == expression.Length - 1)
{
return(null);
}
string t = expression.Substring(i + 1);
// Console.WriteLine("in Using Statement");
string[] namespaces = parserService.GetNamespaceList(t);
if (namespaces == null || namespaces.Length <= 0)
{
return(null);
}
return(new ResolveResult(namespaces));
}
Console.WriteLine("Not in Using");
this.caretLine = caretLineNumber;
this.caretColumn = caretColumn;
this.parserService = parserService;
IParseInformation parseInfo = parserService.GetParseInformation(fileName);
JRefactory.Parser.AST.CompilationUnit fileCompilationUnit = parseInfo.MostRecentCompilationUnit.Tag as JRefactory.Parser.AST.CompilationUnit;
if (fileCompilationUnit == null)
{
// JRefactory.Parser.Parser fileParser = new JRefactory.Parser.Parser();
// fileParser.Parse(new Lexer(new StringReader(fileContent)));
Console.WriteLine("!Warning: no parseinformation!");
return(null);
}
/*
* //// try to find last expression in original string, it could be like " if (act!=null) act"
* //// in this case only "act" should be parsed as expression
* !!is so!! don't change things that work
* Expression expr=null; // tentative expression
* Lexer l=null;
* JRefactory.Parser.Parser p = new JRefactory.Parser.Parser();
* while (expression.Length > 0) {
* l = new Lexer(new StringReader(expression));
* expr = p.ParseExpression(l);
* if (l.LookAhead.val != "" && expression.LastIndexOf(l.LookAhead.val) >= 0) {
* if (expression.Substring(expression.LastIndexOf(l.LookAhead.val) + l.LookAhead.val.Length).Length > 0)
* expression=expression.Substring(expression.LastIndexOf(l.LookAhead.val) + l.LookAhead.val.Length).Trim();
* else {
* expression=l.LookAhead.val.Trim();
* l=new Lexer(new StringReader(expression));
* expr=p.ParseExpression(l);
* break;
* }
* } else {
* if (l.Token.val!="" || expr!=null) break;
* }
* }
* //// here last subexpression should be fixed in expr
* if it should be changed in expressionfinder don't fix it here
*/
JRefactory.Parser.Parser p = new JRefactory.Parser.Parser();
Lexer l = new Lexer(new StringReader(expression));
Expression expr = p.ParseExpression(l);
if (expr == null)
{
return(null);
}
lookupTableVisitor = new LookupTableVisitor();
lookupTableVisitor.Visit(fileCompilationUnit, null);
TypeVisitor typeVisitor = new TypeVisitor(this);
JavaVisitor cSharpVisitor = new JavaVisitor();
cu = (ICompilationUnit)cSharpVisitor.Visit(fileCompilationUnit, null);
if (cu != null)
{
callingClass = GetInnermostClass();
//Console.WriteLine("CallingClass is " + callingClass == null ? "null" : callingClass.Name);
}
//Console.WriteLine("expression = " + expr.ToString());
IReturnType type = expr.AcceptVisitor(typeVisitor, null) as IReturnType;
//Console.WriteLine("type visited");
if (type == null || type.PointerNestingLevel != 0)
{
// Console.WriteLine("Type == null || type.PointerNestingLevel != 0");
if (type != null)
{
//Console.WriteLine("PointerNestingLevel is " + type.PointerNestingLevel);
}
else
{
//Console.WriteLine("Type == null");
}
//// when type is null might be file needs to be reparsed - some vars were lost
fileCompilationUnit = parserService.ParseFile(fileName, fileContent).MostRecentCompilationUnit.Tag
as JRefactory.Parser.AST.CompilationUnit;
lookupTableVisitor.Visit(fileCompilationUnit, null);
cu = (ICompilationUnit)cSharpVisitor.Visit(fileCompilationUnit, null);
if (cu != null)
{
callingClass = GetInnermostClass();
}
type = expr.AcceptVisitor(typeVisitor, null) as IReturnType;
if (type == null)
{
return(null);
}
}
if (type.ArrayDimensions != null && type.ArrayDimensions.Length > 0)
{
type = new ReturnType("System.Array");
}
Console.WriteLine("Here: Type is " + type.FullyQualifiedName);
IClass returnClass = SearchType(type.FullyQualifiedName, cu);
if (returnClass == null)
{
// Try if type is Namespace:
string n = SearchNamespace(type.FullyQualifiedName, cu);
if (n == null)
{
return(null);
}
ArrayList content = parserService.GetNamespaceContents(n);
ArrayList classes = new ArrayList();
for (int i = 0; i < content.Count; ++i)
{
if (content[i] is IClass)
{
classes.Add((IClass)content[i]);
}
}
string[] namespaces = parserService.GetNamespaceList(n);
return(new ResolveResult(namespaces, classes));
}
Console.WriteLine("Returning Result!");
return(new ResolveResult(returnClass, ListMembers(new ArrayList(), returnClass)));
}
ConstructedReturnType ListOf(IReturnType element)
{
return(new ConstructedReturnType(msc.GetClass("System.Collections.Generic.List", 1).DefaultReturnType, new IReturnType[] { element }));
}
public ArrayIndexer(IReturnType elementType, IClass systemArray)
: base("Indexer", elementType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, systemArray)
{
IsIndexer = true;
}
public void TypeParameterPassedToBaseClassTestString()
{
IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(msc.SystemTypes.String, EnumerableClass, 0);
Assert.AreEqual("System.Char", res.FullyQualifiedName);
}
// no methods or indexer
public IReturnType SearchMember(IReturnType type, string memberName)
{
if (type == null || memberName == null || memberName == "")
{
return(null);
}
// Console.WriteLine("searching member {0} in {1}", memberName, type.Name);
IClass curType = SearchType(type.FullyQualifiedName, cu);
if (curType == null)
{
// Console.WriteLine("Type not found in SearchMember");
return(null);
}
if (type.PointerNestingLevel != 0)
{
return(null);
}
if (type.ArrayDimensions != null && type.ArrayDimensions.Length > 0)
{
curType = SearchType("System.Array", null);
}
if (curType.ClassType == ClassType.Enum)
{
foreach (IField f in curType.Fields)
{
if (f.Name == memberName && MustBeShowen(curType, f))
{
showStatic = false;
return(type); // enum members have the type of the enum
}
}
}
if (showStatic)
{
// Console.WriteLine("showStatic == true");
foreach (IClass c in curType.InnerClasses)
{
if (c.Name == memberName && IsAccessible(curType, c))
{
return(new ReturnType(c.FullyQualifiedName));
}
}
}
// Console.WriteLine("#Properties " + curType.Properties.Count);
foreach (IProperty p in curType.Properties)
{
// Console.WriteLine("checke Property " + p.Name);
// Console.WriteLine("member name " + memberName);
if (p.Name == memberName && MustBeShowen(curType, p))
{
// Console.WriteLine("Property found " + p.Name);
showStatic = false;
return(p.ReturnType);
}
}
foreach (IField f in curType.Fields)
{
// Console.WriteLine("checke Feld " + f.Name);
// Console.WriteLine("member name " + memberName);
if (f.Name == memberName && MustBeShowen(curType, f))
{
// Console.WriteLine("Field found " + f.Name);
showStatic = false;
return(f.ReturnType);
}
}
foreach (IEvent e in curType.Events)
{
if (e.Name == memberName && MustBeShowen(curType, e))
{
showStatic = false;
return(e.ReturnType);
}
}
foreach (string baseType in curType.BaseTypes)
{
IClass c = SearchType(baseType, curType.CompilationUnit);
if (c != null)
{
IReturnType erg = SearchMember(new ReturnType(c.FullyQualifiedName), memberName);
if (erg != null)
{
return(erg);
}
}
}
return(null);
}
/// <summary>
/// Tests if an implicit conversion exists from "from" to "to".
/// Conversions from concrete types to generic types are only allowed when the generic type belongs to the
/// method "allowGenericTargetsOnThisMethod".
/// </summary>
static bool ConversionExistsInternal(IReturnType from, IReturnType to, IMethod allowGenericTargetsOnThisMethod)
{
// ECMA-334, § 13.1 Implicit conversions
// Identity conversion:
if (from == to)
{
return(true);
}
if (from == null || to == null)
{
return(false);
}
if (from.Equals(to))
{
return(true);
}
bool fromIsDefault = from.IsDefaultReturnType;
bool toIsDefault = to.IsDefaultReturnType;
if (fromIsDefault && toIsDefault)
{
// Implicit numeric conversions:
int f = GetPrimitiveType(from);
int t = GetPrimitiveType(to);
if (f == SByte && (t == Short || t == Int || t == Long || t == Float || t == Double || t == Decimal))
{
return(true);
}
if (f == Byte && (t == Short || t == UShort || t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal))
{
return(true);
}
if (f == Short && (t == Int || t == Long || t == Float || t == Double || t == Decimal))
{
return(true);
}
if (f == UShort && (t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal))
{
return(true);
}
if (f == Int && (t == Long || t == Float || t == Double || t == Decimal))
{
return(true);
}
if (f == UInt && (t == Long || t == ULong || t == Float || t == Double || t == Decimal))
{
return(true);
}
if ((f == Long || f == ULong) && (t == Float || t == Double || t == Decimal))
{
return(true);
}
if (f == Char && (t == UShort || t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal))
{
return(true);
}
if (f == Float && t == Double)
{
return(true);
}
}
// Implicit reference conversions:
if (toIsDefault && to.FullyQualifiedName == "System.Object")
{
return(true); // from any type to object
}
if (from == NullReturnType.Instance)
{
IClass toClass = to.GetUnderlyingClass();
if (toClass != null)
{
switch (toClass.ClassType)
{
case ClassType.Class:
case ClassType.Delegate:
case ClassType.Interface:
return(true);
case ClassType.Struct:
return(toClass.FullyQualifiedName == "System.Nullable");
}
}
return(false);
}
if ((toIsDefault || to.IsConstructedReturnType || to.IsGenericReturnType) &&
(fromIsDefault || from.IsArrayReturnType || from.IsConstructedReturnType))
{
foreach (IReturnType baseTypeOfFrom in GetTypeInheritanceTree(from))
{
if (IsConstructedConversionToGenericReturnType(baseTypeOfFrom, to, allowGenericTargetsOnThisMethod))
{
return(true);
}
}
}
if (from.IsArrayReturnType && to.IsArrayReturnType)
{
ArrayReturnType fromArt = from.CastToArrayReturnType();
ArrayReturnType toArt = to.CastToArrayReturnType();
// from array to other array type
if (fromArt.ArrayDimensions == toArt.ArrayDimensions)
{
return(ConversionExistsInternal(fromArt.ArrayElementType, toArt.ArrayElementType, allowGenericTargetsOnThisMethod));
}
}
if (from.IsDecoratingReturnType <AnonymousMethodReturnType>() && (toIsDefault || to.IsConstructedReturnType))
{
AnonymousMethodReturnType amrt = from.CastToDecoratingReturnType <AnonymousMethodReturnType>();
IMethod method = CSharp.TypeInference.GetDelegateOrExpressionTreeSignature(to, amrt.CanBeConvertedToExpressionTree);
if (method != null)
{
if (amrt.HasParameterList)
{
if (amrt.MethodParameters.Count != method.Parameters.Count)
{
return(false);
}
for (int i = 0; i < amrt.MethodParameters.Count; i++)
{
if (amrt.MethodParameters[i].ReturnType != null)
{
if (!object.Equals(amrt.MethodParameters[i].ReturnType,
method.Parameters[i].ReturnType))
{
return(false);
}
}
}
}
IReturnType rt = amrt.ResolveReturnType(method.Parameters.Select(p => p.ReturnType).ToArray());
return(ConversionExistsInternal(rt, method.ReturnType, allowGenericTargetsOnThisMethod));
}
}
return(false);
}
public override IType GetType(IReturnType returnType)
{
return(CheckType(base.GetType(returnType)));
}
public Constructor(ModifierEnum m, IReturnType returnType, IClass declaringType)
: base((m & ModifierEnum.Static) != 0 ? "#cctor" : "#ctor",
returnType, m, DomRegion.Empty, DomRegion.Empty, declaringType)
{
}
/// <summary>
/// Gets the common base type of a and b.
/// </summary>
public static IReturnType GetCommonType(IProjectContent projectContent, IReturnType a, IReturnType b)
{
if (projectContent == null)
{
throw new ArgumentNullException("projectContent");
}
if (a == null)
{
return(b);
}
if (b == null)
{
return(a);
}
if (ConversionExists(a, b))
{
return(b);
}
//if (ConversionExists(b, a)) - not required because the first baseTypeOfA is a
// return a;
foreach (IReturnType baseTypeOfA in GetTypeInheritanceTree(a))
{
if (ConversionExists(b, baseTypeOfA))
{
return(baseTypeOfA);
}
}
return(projectContent.SystemTypes.Object);
}
internal ResolveResult CreateResult(IReturnType type)
{
return(CreateResult(resolver.Unit, type));
}
/// <summary>
/// Checks if an implicit conversion exists from <paramref name="from"/> to <paramref name="to"/>.
/// </summary>
public static bool ConversionExists(IReturnType from, IReturnType to)
{
return(ConversionExistsInternal(from, to, null));
}
/* public virtual IType SearchType (SearchTypeRequest request)
* {
* return SearchType (request.Name, request.CallingType, request.CurrentCompilationUnit, request.GenericParameters);
* }*/
internal IType SearchType(ICompilationUnit unit, IType callingClass, DomLocation lookupLocation, string name, IList <IReturnType> genericParameters)
{
// TODO dom check generic parameter count
if (string.IsNullOrEmpty(name))
{
return(null);
}
IType result = null;
// It may be one of the generic parameters in the calling class
if (genericParameters == null || genericParameters.Count == 0)
{
if (callingClass != null)
{
result = FindGenericParameter(unit, ResolveType(callingClass), name);
if (result != null)
{
return(result);
}
}
}
// A known type?
result = GetType(name, genericParameters, false, true);
if (result != null)
{
return(result);
}
// Maybe an inner type that isn't fully qualified?
if (callingClass != null)
{
IType t = ResolveType(callingClass);
result = SearchInnerType(t, name.Split('.'), 0, genericParameters != null ? genericParameters.Count : 0, true);
if (result != null)
{
if (genericParameters != null && genericParameters.Count > 0)
{
return(CreateInstantiatedGenericType(result, genericParameters));
}
return(result);
}
}
// If the name matches an alias, try using the alias first.
if (unit != null)
{
IReturnType ualias = FindAlias(name, unit.Usings);
if (ualias != null)
{
// Don't provide the compilation unit when trying to resolve the alias,
// since aliases are not affected by other 'using' directives.
result = GetType(ualias.FullName, ualias.GenericArguments, false, true);
if (result != null)
{
return(result);
}
}
}
// The enclosing namespace has preference over the using directives.
// Check it now.
if (callingClass != null)
{
List <int> indices = new List <int> ();
string str = callingClass.FullName;
for (int i = 0; i < str.Length; i++)
{
if (str[i] == '.')
{
indices.Add(i);
}
}
for (int n = indices.Count - 1; n >= 0; n--)
{
if (n < 1)
{
continue;
}
string curnamespace = str.Substring(0, indices[n] + 1);
result = GetType(curnamespace + name, genericParameters, false, true);
if (result != null)
{
return(result);
}
}
}
// Now try to find the class using the included namespaces
if (unit != null)
{
// it's a difference having using A; namespace B { } or namespace B { using A; }, when a type
// request equals a namespace name; for example the type B could be resolved in the 2nd case when a type
// A.B exists but not in the 1st.
foreach (IUsing u in unit.Usings.Reverse())
{
if (u.Namespaces.Contains(name))
{
return(null);
}
if (callingClass != null && !u.ValidRegion.Contains(lookupLocation))
{
continue;
}
if (u != null)
{
result = SearchType(u, name, genericParameters, true);
if (result != null)
{
return(result);
}
}
}
}
return(null);
}
IReturnType GetCommonType(IReturnType left, IReturnType right)
{
return(left ?? right);
}
public IType GetArrayType(IReturnType elementType)
{
return(GetArrayType(elementType, MonoDevelop.Projects.Dom.Output.AmbienceService.DefaultAmbience));
}
