public override TypeDefinitionBase TypeOfTypeParameter(SD_Type_Parameter tp)
{
if (typeParameters != null)
{
var index = typeParameters.IndexOf(tp);
if (index >= 0)
{
return(typeArguments[index].Definition as TypeDefinitionBase ?? tp);
}
}
return(base.TypeOfTypeParameter(tp));
}
public override TypeDefinitionBase TypeOfTypeParameter(SD_Type_Parameter tp)
{
var fromReferencedSymbol = referencedSymbol.TypeOfTypeParameter(tp);
var asTypeParameter = fromReferencedSymbol as SD_Type_Parameter;
if (asTypeParameter != null)
{
return(base.TypeOfTypeParameter(tp));
}
else
{
return(fromReferencedSymbol);
}
}
public override TypeDefinitionBase TypeOfTypeParameter(SD_Type_Parameter tp)
{
return(tp);
}
public SD_Type_Reflected(Type type)
{
reflectedType = type;
modifiers = type.IsNested ?
(type.IsNestedPublic ? Modifiers.Public :
type.IsNestedFamORAssem ? Modifiers.Internal | Modifiers.Protected :
type.IsNestedAssembly ? Modifiers.Internal :
type.IsNestedFamily ? Modifiers.Protected :
Modifiers.Private)
:
(type.IsPublic ? Modifiers.Public :
!type.IsVisible ? Modifiers.Internal :
Modifiers.Private);
if (type.IsAbstract && type.IsSealed)
{
modifiers |= Modifiers.Static;
}
else if (type.IsAbstract)
{
modifiers |= Modifiers.Abstract;
}
else if (type.IsSealed)
{
modifiers |= Modifiers.Sealed;
}
accessLevel = AccessLevelFromModifiers(modifiers);
var assemblyDefinition = SD_Assembly.FromAssembly(type.Assembly);
var generic = type.Name.IndexOf('`');
name = generic < 0 ? type.Name : type.Name.Substring(0, generic);
name = name.Replace("[*]", "[]");
parentSymbol = string.IsNullOrEmpty(type.Namespace) ? assemblyDefinition.GlobalNamespace : assemblyDefinition.FindNamespace(type.Namespace);
if (type.IsInterface)
{
kind = SymbolKind.Interface;
}
else if (type.IsEnum)
{
kind = SymbolKind.Enum;
}
else if (type.IsValueType)
{
kind = SymbolKind.Struct;
}
else if (type.IsClass)
{
kind = SymbolKind.Class;
if (type.BaseType == typeof(System.MulticastDelegate))
{
kind = SymbolKind.Delegate;
}
}
else
{
kind = SymbolKind.None;
}
if (type.IsGenericTypeDefinition)
{
var gtd = type.GetGenericTypeDefinition() ?? type;
var tp = gtd.GetGenericArguments();
var numGenericArgs = tp.Length;
var declaringType = gtd.DeclaringType;
if (declaringType != null && declaringType.IsGenericType)
{
var parentArgs = declaringType.GetGenericArguments();
numGenericArgs -= parentArgs.Length;
}
if (numGenericArgs > 0)
{
typeParameters = new List <SD_Type_Parameter>(numGenericArgs);
for (var i = tp.Length - numGenericArgs; i < tp.Length; ++i)
{
var tpDef = new SD_Type_Parameter {
kind = SymbolKind.TypeParameter, name = tp[i].Name, parentSymbol = this
};
typeParameters.Add(tpDef);
}
}
}
if (type.BaseType != null)
{
baseType = ReflectedTypeReference.ForType(type.BaseType ?? typeof(object));
}
interfaces = new List <SymbolReference>();
var implements = type.GetInterfaces();
for (var i = 0; i < implements.Length; ++i)
{
interfaces.Add(ReflectedTypeReference.ForType(implements[i]));
}
if (IsStatic && NumTypeParameters == 0 && !type.IsNested)
{
var attributes = System.Attribute.GetCustomAttributes(type);
foreach (var attribute in attributes)
{
if (attribute is System.Runtime.CompilerServices.ExtensionAttribute)
{
ReflectAllMembers(BindingFlags.Public | BindingFlags.NonPublic);
break;
}
}
}
}
public SD_Method_Reflected(MethodInfo methodInfo, SymbolDefinition memberOf)
{
modifiers =
methodInfo.IsPublic ? Modifiers.Public :
methodInfo.IsFamilyOrAssembly ? Modifiers.Internal | Modifiers.Protected :
methodInfo.IsAssembly ? Modifiers.Internal :
methodInfo.IsFamily ? Modifiers.Protected :
Modifiers.Private;
if (methodInfo.IsAbstract)
{
modifiers |= Modifiers.Abstract;
}
if (methodInfo.IsVirtual)
{
modifiers |= Modifiers.Virtual;
}
if (methodInfo.IsStatic)
{
modifiers |= Modifiers.Static;
}
if (methodInfo.GetBaseDefinition().DeclaringType != methodInfo.DeclaringType)
{
modifiers = (modifiers & ~Modifiers.Virtual) | Modifiers.Override;
}
if (methodInfo.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false) && IsStatic)
{
var parentType = memberOf.parentSymbol as TypeDefinitionBase;
if (parentType.kind == SymbolKind.Class && parentType.IsStatic && parentType.NumTypeParameters == 0)
{
isExtensionMethod = true;
++parentType.numExtensionMethods;
}
}
accessLevel = AccessLevelFromModifiers(modifiers);
reflectedMethodInfo = methodInfo;
var genericMarker = methodInfo.Name.IndexOf('`');
name = genericMarker < 0 ? methodInfo.Name : methodInfo.Name.Substring(0, genericMarker);
parentSymbol = memberOf;
var tp = methodInfo.GetGenericArguments();
if (tp.Length > 0)
{
var numGenericArgs = tp.Length;
typeParameters = new List <SD_Type_Parameter>(tp.Length);
for (var i = tp.Length - numGenericArgs; i < tp.Length; ++i)
{
var tpDef = new SD_Type_Parameter {
kind = SymbolKind.TypeParameter, name = tp[i].Name, parentSymbol = this
};
typeParameters.Add(tpDef);
}
}
returnType = ReflectedTypeReference.ForType(methodInfo.ReturnType);
if (parameters == null)
{
parameters = new List <SD_Instance_Parameter>();
}
var methodParameters = methodInfo.GetParameters();
for (var i = 0; i < methodParameters.Length; ++i)
{
var p = methodParameters[i];
var isByRef = p.ParameterType.IsByRef;
var parameterType = isByRef ? p.ParameterType.GetElementType() : p.ParameterType;
var parameterToAdd = new SD_Instance_Parameter
{
kind = SymbolKind.Parameter,
parentSymbol = this,
name = p.Name,
type = ReflectedTypeReference.ForType(parameterType),
modifiers = isByRef ? (p.IsOut ? Modifiers.Out : Modifiers.Ref) : Attribute.IsDefined(p, typeof(ParamArrayAttribute)) ? Modifiers.Params : Modifiers.None,
};
if (i == 0 && isExtensionMethod)
{
parameterToAdd.modifiers |= Modifiers.This;
}
if (p.RawDefaultValue != DBNull.Value)
{
//var dv = Attribute.GetCustomAttribute(p, typeof(System.ComponentModel.DefaultValueAttribute));
parameterToAdd.defaultValue = p.RawDefaultValue == null ? "null" : p.RawDefaultValue.ToString();
}
parameters.Add(parameterToAdd);
}
}
