public static NameType TryGetName(TotemType dt, EventInfo ei, MethodInfo eventMethod, out string name) { name = ei.Name; NameType res = dt.IsTotemType ? NameType.TotemEvent : NameType.Event; return GetNameFromMethod(dt, eventMethod, res, ref name); }
public TotemObject(TotemType/*!*/ type) { Assert.NotNull(type); Debug.Assert(type.Handles(GetType())); _type = type; _context = type.Context; }
public static NameType TryGetName(TotemType dt, PropertyInfo pi, MethodInfo prop, out string name) { //if (pi.IsDefined(typeof(TotemHiddenAttribute), false)) //{ // name = null; // return NameType.None; //} name = pi.Name; return GetNameFromMethod(dt, prop, NameType.Property, ref name); }
internal static NameType GetNameFromMethod(TotemType dt, MethodInfo mi, NameType res, ref string name) { string namePrefix = null; if (mi.IsPrivate || (mi.IsAssembly && !mi.IsFamilyOrAssembly)) { // allow explicitly implemented interface if (!(mi.IsPrivate && mi.IsFinal && mi.IsHideBySig && mi.IsVirtual)) { // mangle protectes to private namePrefix = "_" + dt.Name + "__"; } else { // explicitly implemented interface // drop the namespace, leave the interface name, and replace // the dot with an underscore. Eg System.IConvertible.ToBoolean // becomes IConvertible_ToBoolean int lastDot = name.LastIndexOf('.'); if (lastDot != -1) name = name.Substring(lastDot + 1); } } if (namePrefix != null) name = namePrefix + name; if (mi.DeclaringType.GetTypeInfo().IsDefined(typeof(TotemTypeAttribute), false) || !mi.DeclaringType.IsAssignableFrom(dt.UnderlyingSystemType)) { // extension types are all totem names res |= NameType.Totem; } //if (mi.IsDefined(typeof(TotemMethodAttribute), false)) //{ // res = NameType(res & ~NameType.BaseTypeMask) | NameType.Property; //} return res; }
private static OverloadInfo CreateOverloadInfo(TotemType.MethodOrFunction methodOrFunction) { if (methodOrFunction.Method != null) return new ReflectionOverloadInfo(methodOrFunction.Method); else throw new NotImplementedException(); }
private Dictionary<string, DynamicProperty> EnsureProperties(TotemType type, Type totemType) { var ret = EnsureProperties(totemType); var staticProps = _staticProperties[totemType]; foreach (var t in type.ParentTypes) { Debug.Assert(typeof(TotemType).IsAssignableFrom(t)); var seed = EnsureProperties(t); foreach (var s in seed) { if (s.Value.Methods == null || s.Value.Methods.Count == 0) continue; DynamicProperty dp; if (!ret.TryGetValue(s.Key, out dp)) dp = ret[s.Key] = new DynamicProperty(); dp.CompiledMethods = null; if (dp.Methods == null) dp.Methods = new List<Tuple<MethodInfo, DynamicFlags>>(s.Value.Methods); else dp.Methods = new List<Tuple<MethodInfo, DynamicFlags>>(dp.Methods.Union(s.Value.Methods)); if (!staticProps.TryGetValue(s.Key, out dp)) dp = staticProps[s.Key] = new DynamicProperty(); dp.CompiledMethods = null; if (dp.Methods == null) dp.Methods = new List<Tuple<MethodInfo, DynamicFlags>>(s.Value.Methods); else dp.Methods = new List<Tuple<MethodInfo, DynamicFlags>>(dp.Methods.Union(s.Value.Methods)); } } return ret; }
static void Implement(TotemType target, string name, ITotemCallable callable) { target.Implement(name, callable); }
static string ConvertString(TotemType type, object obj) { ContractUtils.RequiresNotNull(obj, "obj"); Debug.Assert(type.Handles(obj.GetType())); return type.ToString(obj); }
public MetaObject(TotemType type, Expression expression, BindingRestrictions restrictions, object value) : base(expression, restrictions, value) { _type = type; }
internal TotemOverload(TotemContext context, TotemType type, string name, Tuple<MethodInfo, TotemType.DynamicFlags>/*!*/[]/*!*/ methodInfos) : base(context.GetType<Overloaded>()) { ContractUtils.RequiresNotNull(methodInfos, "methodInfos"); ContractUtils.RequiresNotNull(name, "name"); ContractUtils.RequiresNotNull(type, "type"); _methodInfos = methodInfos; _name = name; _typeDefinition = type; }
private int PreArgsCount(TotemType.DynamicFlags flags) { int count = 0; if ((flags & TotemType.DynamicFlags.RequiresType) != 0) count++; if ((flags & TotemType.DynamicFlags.RequiresContext) != 0) count++; return count; }
internal static TotemOverload Create(TotemContext/*!*/ context, TotemType/*!*/ type, string name, Tuple<MethodInfo, TotemType.DynamicFlags>/*!*/[]/*!*/ methodInfos) { return new TotemOverload(context, type, name, methodInfos); }
private static ReadOnlyDictionary<TotemOperationKind, ReadOnlyCollection<MethodOrFunction>> GetOperators(TotemType type) { Debug.Assert(type.IsSystemType, "Should only be called for system types as totem types should populate operators by themselves"); if(!type.IsTotemType) return new ReadOnlyDictionary<TotemOperationKind, ReadOnlyCollection<MethodOrFunction>>( new Dictionary<TotemOperationKind, ReadOnlyCollection<MethodOrFunction>>()); Dictionary<TotemOperationKind, ReadOnlyCollection<MethodOrFunction>> ops = new Dictionary<TotemOperationKind, ReadOnlyCollection<MethodOrFunction>>(); var t = TotemBinder.GetProxyType(type.UnderlyingSystemType) ?? type.UnderlyingSystemType; var methods = t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly) .GroupBy(m => m.Name); var names = Enum.GetNames(typeof(TotemOperationKind)); foreach (var methodGroup in methods) { var builder = new ReadOnlyCollectionBuilder<MethodOrFunction>(); foreach (var method in methodGroup) { if(method.IsSpecialName) builder.Add(new MethodOrFunction(method)); } if (builder.Count > 0) { TotemOperationKind kind; if (Enum.TryParse<TotemOperationKind>(methodGroup.Key, out kind)) ops.Add(kind, builder.ToReadOnlyCollection()); } } return new ReadOnlyDictionary<TotemOperationKind, ReadOnlyCollection<MethodOrFunction>>(ops); }
internal static TotemType/*!*/ GetTotemType(Type type) { object res; if (!_totemTypes.TryGetValue(type, out res)) { lock (_totemTypes) { if (!_totemTypes.TryGetValue(type, out res)) { res = new TotemType(type); _totemTypes.Add(type, res); } } } return (TotemType)res; }
public static NameType TryGetName(TotemType dt, MethodInfo mi, out string name) { name = mi.Name; return GetNameFromMethod(dt, mi, NameType.Method, ref name); }