TypeReference.cs 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
  1. using System;
  2. using System.Collections.Concurrent;
  3. using System.Reflection;
  4. using Jint.Collections;
  5. using Jint.Native;
  6. using Jint.Native.Function;
  7. using Jint.Native.Object;
  8. using Jint.Runtime.Descriptors;
  9. using Jint.Runtime.Interop.Reflection;
  10. namespace Jint.Runtime.Interop
  11. {
  12. public sealed class TypeReference : FunctionInstance, IConstructor, IObjectWrapper
  13. {
  14. private static readonly JsString _name = new JsString("typereference");
  15. private static readonly ConcurrentDictionary<Type, MethodDescriptor[]> _constructorCache = new();
  16. private static readonly ConcurrentDictionary<Tuple<Type, string>, ReflectionAccessor> _memberAccessors = new();
  17. private TypeReference(Engine engine, Type type)
  18. : base(engine, engine.Realm, _name, FunctionThisMode.Global, ObjectClass.TypeReference)
  19. {
  20. ReferenceType = type;
  21. _prototype = engine.Realm.Intrinsics.Function.PrototypeObject;
  22. _length = PropertyDescriptor.AllForbiddenDescriptor.NumberZero;
  23. _prototypeDescriptor = new PropertyDescriptor(engine.Realm.Intrinsics.Object.PrototypeObject, PropertyFlag.AllForbidden);
  24. PreventExtensions();
  25. }
  26. public Type ReferenceType { get; }
  27. public static TypeReference CreateTypeReference<T>(Engine engine)
  28. {
  29. return CreateTypeReference(engine, typeof(T));
  30. }
  31. public static TypeReference CreateTypeReference(Engine engine, Type type)
  32. {
  33. return new TypeReference(engine, type);
  34. }
  35. public override JsValue Call(JsValue thisObject, JsValue[] arguments)
  36. {
  37. // direct calls on a TypeReference constructor object is equivalent to the new operator
  38. return Construct(arguments);
  39. }
  40. ObjectInstance IConstructor.Construct(JsValue[] arguments, JsValue newTarget) => Construct(arguments);
  41. private ObjectInstance Construct(JsValue[] arguments)
  42. {
  43. ObjectInstance result = null;
  44. if (arguments.Length == 0 && ReferenceType.IsValueType)
  45. {
  46. var instance = Activator.CreateInstance(ReferenceType);
  47. result = TypeConverter.ToObject(_realm, FromObject(Engine, instance));
  48. }
  49. else
  50. {
  51. var constructors = _constructorCache.GetOrAdd(
  52. ReferenceType,
  53. t => MethodDescriptor.Build(t.GetConstructors(BindingFlags.Public | BindingFlags.Instance)));
  54. foreach (var (method, _, _) in TypeConverter.FindBestMatch(_engine, constructors, _ => arguments))
  55. {
  56. var retVal = method.Call(Engine, null, arguments);
  57. result = TypeConverter.ToObject(_realm, retVal);
  58. // todo: cache method info
  59. break;
  60. }
  61. }
  62. if (result is not null)
  63. {
  64. if (result is ObjectWrapper objectWrapper)
  65. {
  66. // allow class extension
  67. objectWrapper._allowAddingProperties = true;
  68. }
  69. return result;
  70. }
  71. ExceptionHelper.ThrowTypeError(_engine.Realm, "No public methods with the specified arguments were found.");
  72. return null;
  73. }
  74. internal override bool OrdinaryHasInstance(JsValue v)
  75. {
  76. if (v is IObjectWrapper wrapper)
  77. {
  78. return wrapper.Target.GetType() == ReferenceType;
  79. }
  80. return base.OrdinaryHasInstance(v);
  81. }
  82. public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
  83. {
  84. return false;
  85. }
  86. public override bool Delete(JsValue property)
  87. {
  88. return false;
  89. }
  90. public override bool Set(JsValue property, JsValue value, JsValue receiver)
  91. {
  92. if (!CanPut(property))
  93. {
  94. return false;
  95. }
  96. var ownDesc = GetOwnProperty(property);
  97. if (ownDesc == null)
  98. {
  99. return false;
  100. }
  101. ownDesc.Value = value;
  102. return true;
  103. }
  104. public override PropertyDescriptor GetOwnProperty(JsValue property)
  105. {
  106. if (property is not JsString jsString)
  107. {
  108. return PropertyDescriptor.Undefined;
  109. }
  110. var key = jsString._value;
  111. var descriptor = PropertyDescriptor.Undefined;
  112. if (_properties?.TryGetValue(key, out descriptor) != true)
  113. {
  114. descriptor = CreatePropertyDescriptor(key);
  115. if (!ReferenceEquals(descriptor, PropertyDescriptor.Undefined))
  116. {
  117. _properties ??= new PropertyDictionary();
  118. _properties[key] = descriptor;
  119. return descriptor;
  120. }
  121. }
  122. return base.GetOwnProperty(property);
  123. }
  124. private PropertyDescriptor CreatePropertyDescriptor(string name)
  125. {
  126. var key = new Tuple<Type, string>(ReferenceType, name);
  127. var accessor = _memberAccessors.GetOrAdd(key, x => ResolveMemberAccessor(x.Item1, x.Item2));
  128. return accessor.CreatePropertyDescriptor(_engine, ReferenceType);
  129. }
  130. private ReflectionAccessor ResolveMemberAccessor(Type type, string name)
  131. {
  132. var typeResolver = _engine.Options.Interop.TypeResolver;
  133. if (type.IsEnum)
  134. {
  135. var memberNameComparer = typeResolver.MemberNameComparer;
  136. var typeResolverMemberNameCreator = typeResolver.MemberNameCreator;
  137. var enumValues = Enum.GetValues(type);
  138. var enumNames = Enum.GetNames(type);
  139. for (var i = 0; i < enumValues.Length; i++)
  140. {
  141. var enumOriginalName = enumNames.GetValue(i).ToString();
  142. var member = type.GetMember(enumOriginalName)[0];
  143. foreach (var exposedName in typeResolverMemberNameCreator(member))
  144. {
  145. if (memberNameComparer.Equals(name, exposedName))
  146. {
  147. var value = enumValues.GetValue(i);
  148. return new ConstantValueAccessor(JsNumber.Create(value));
  149. }
  150. }
  151. }
  152. return ConstantValueAccessor.NullAccessor;
  153. }
  154. const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Static;
  155. return typeResolver.TryFindMemberAccessor(_engine, type, name, bindingFlags, indexerToTry: null, out var accessor)
  156. ? accessor
  157. : ConstantValueAccessor.NullAccessor;
  158. }
  159. public object Target => ReferenceType;
  160. }
  161. }