public static DefaultClass GetDummyClassForTypeParameter(ITypeParameter p)
{
DefaultClass c = new DefaultClass(p.Class.CompilationUnit, p.Name);
if (p.Method != null)
{
c.Region = new DomRegion(p.Method.Region.BeginLine, p.Method.Region.BeginColumn);
}
else
{
c.Region = new DomRegion(p.Class.Region.BeginLine, p.Class.Region.BeginColumn);
}
c.Modifiers = ModifierEnum.Public;
if (p.HasValueTypeConstraint)
{
c.ClassType = ClassType.Struct;
}
else if (p.HasConstructableConstraint)
{
c.ClassType = ClassType.Class;
}
else
{
c.ClassType = ClassType.Interface;
}
return(c);
}
bool ReadClasses()
{
int classCount = reader.ReadInt32();
int externalTypeCount = reader.ReadInt32();
types = new IReturnType[classCount + externalTypeCount];
DefaultClass[] classes = new DefaultClass[classCount];
for (int i = 0; i < classes.Length; i++)
{
DefaultClass c = new DefaultClass(pc.AssemblyCompilationUnit, reader.ReadString());
classes[i] = c;
types[i] = c.DefaultReturnType;
}
for (int i = classCount; i < types.Length; i++)
{
string name = reader.ReadString();
types[i] = new GetClassReturnType(pc, name, reader.ReadByte());
}
stringArray = new string[reader.ReadInt32()];
for (int i = 0; i < stringArray.Length; i++)
{
stringArray[i] = reader.ReadString();
}
ReadAttributes(pc.AssemblyCompilationUnit);
for (int i = 0; i < classes.Length; i++)
{
ReadClass(classes[i]);
pc.AddClassToNamespaceList(classes[i]);
if (reader.ReadByte() != 64)
{
return(false);
}
}
return(true);
}
public IClass GetInnermostClass(int caretLine, int caretColumn)
{
foreach (IClass c in Classes)
{
if (c != null && DefaultClass.IsInside(c, caretLine, caretColumn))
{
return(c.GetInnermostClass(caretLine, caretColumn));
}
}
return(null);
}
public override IClass GetUnderlyingClass()
{
if (cachedClass != null)
{
return(cachedClass);
}
DefaultClass c = new DefaultClass(cu, ClassType.Delegate, ModifierEnum.None, DomRegion.Empty, null);
c.BaseTypes.Add(cu.ProjectContent.SystemTypes.Delegate);
AddDefaultDelegateMethod(c, returnType ?? cu.ProjectContent.SystemTypes.Object, parameters ?? new IParameter[0]);
cachedClass = c;
return(c);
}
static void AddTypeParametersForCtrlSpace(List <ICompletionEntry> result, IEnumerable <ITypeParameter> typeParameters)
{
foreach (ITypeParameter p in typeParameters)
{
DefaultClass c = DefaultTypeParameter.GetDummyClassForTypeParameter(p);
if (p.Method != null)
{
c.Documentation = "Type parameter of " + p.Method.Name;
}
else
{
c.Documentation = "Type parameter of " + p.Class.Name;
}
result.Add(c);
}
}
internal static void AddDefaultDelegateMethod(DefaultClass c, IReturnType returnType, IList <IParameter> parameters)
{
ModifierEnum modifiers = ModifierEnum.Public | ModifierEnum.Synthetic;
DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters)
{
invokeMethod.Parameters.Add(par);
}
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters)
{
invokeMethod.Parameters.Add(par);
}
invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty));
invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty));
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("EndInvoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty));
c.Methods.Add(invokeMethod);
}
void ReadClass(DefaultClass c)
{
this.currentClass = c;
int count;
count = reader.ReadByte();
for (int i = 0; i < count; i++)
{
c.TypeParameters.Add(new DefaultTypeParameter(c, ReadString(), i));
}
if (count > 0)
{
foreach (ITypeParameter typeParameter in c.TypeParameters)
{
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
typeParameter.Constraints.Add(ReadType());
}
}
}
else
{
c.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.BaseTypes.Add(ReadType());
}
c.Modifiers = (ModifierEnum)reader.ReadInt32();
c.CalculatedFlags = reader.ReadByte();
c.ClassType = (ClassType)reader.ReadByte();
ReadAttributes(c);
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
DefaultClass innerClass = new DefaultClass(c.CompilationUnit, c);
innerClass.FullyQualifiedName = reader.ReadString();
c.InnerClasses.Add(innerClass);
ReadClass(innerClass);
}
this.currentClass = c;
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Methods.Add(ReadMethod());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Properties.Add(ReadProperty());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Events.Add(ReadEvent());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
c.Fields.Add(ReadField());
}
this.currentClass = 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);
}