public string GetMember(IMember member)
{
var owner = member is IMethod && ((IMethod)member).IsAccessor ? ((IMethod)member).AccessorOwner : null;
int index = FindIndexInReflectableMembers(owner ?? member);
if (index >= 0)
{
string result = string.Format("Bridge.getMetadata({0}).m[{1}]", ExpressionTreeBuilder.GetTypeName(member.DeclaringType, this._emitter), index);
if (owner != null)
{
if (owner is IProperty)
{
if (ReferenceEquals(member, ((IProperty)owner).Getter))
{
result = result + ".g";
}
else if (ReferenceEquals(member, ((IProperty)owner).Setter))
{
result = result + ".s";
}
else
{
throw new ArgumentException("Invalid member " + member);
}
}
else if (owner is IEvent)
{
if (ReferenceEquals(member, ((IEvent)owner).AddAccessor))
{
result = result + ".ad";
}
else if (ReferenceEquals(member, ((IEvent)owner).RemoveAccessor))
{
result = result + ".r";
}
else
{
throw new ArgumentException("Invalid member " + member);
}
}
else
{
throw new ArgumentException("Invalid owner " + owner);
}
}
return(result);
}
else
{
return(MetadataUtils.ConstructMemberInfo(member, this._emitter, true, false, this._syntaxTree).ToString(Formatting.None));
}
}
public static JObject ConstructITypeMetadata(IType type, IEmitter emitter)
{
var properties = MetadataUtils.GetCommonTypeProperties(type, emitter);
if (type.Kind == TypeKind.Class || type.Kind == TypeKind.Anonymous)
{
var members = type.GetMembers(null, GetMemberOptions.IgnoreInheritedMembers).Where(m => MetadataUtils.IsReflectable(m, emitter, false, null))
.OrderBy(m => m, MemberOrderer.Instance)
.Select(m => MetadataUtils.ConstructMemberInfo(m, emitter, false, false, null))
.ToList();
if (members.Count > 0)
{
properties.Add("m", new JArray(members));
}
}
return(properties.Count > 0 ? properties : null);
}
public static JObject ConstructMemberInfo(IMember m, IEmitter emitter, bool includeDeclaringType, bool isGenericSpecialization, SyntaxTree tree)
{
if (m is IMethod && ((IMethod)m).IsConstructor)
{
return(MetadataUtils.ConstructConstructorInfo((IMethod)m, emitter, includeDeclaringType, isGenericSpecialization, tree));
}
var properties = MetadataUtils.GetCommonMemberInfoProperties(m, emitter, includeDeclaringType, isGenericSpecialization, tree);
if (m.IsStatic)
{
properties.Add("is", true);
}
if (m is IMethod)
{
var method = (IMethod)m;
var inline = emitter.GetInline(method);
if (string.IsNullOrEmpty(inline) && method.Attributes.Any(a => a.AttributeType.FullName == "Bridge.ExpandParamsAttribute"))
{
properties.Add("exp", true);
}
properties.Add("t", (int)MemberTypes.Method);
var parametersInfo = method.Parameters.Select(p => MetadataUtils.ConstructParameterInfo(p, emitter, false, false, tree)).ToList();
if (parametersInfo.Count > 0)
{
properties.Add("pi", new JArray(parametersInfo));
}
if (!string.IsNullOrEmpty(inline))
{
if (inline.StartsWith("<self>"))
{
inline = inline.Substring(6);
}
var block = new InlineArgumentsBlock(emitter, new ArgumentsInfo(emitter, method), inline, method);
var oldWriter = block.SaveWriter();
block.NewWriter();
block.EmitFunctionReference(true);
var str = emitter.Output.ToString();
block.RestoreWriter(oldWriter);
properties.Add("tpc", method.TypeParameters.Count);
properties.Add("def", new JRaw(str));
}
else
{
if (MetadataUtils.IsJsGeneric(method, emitter))
{
properties.Add("tpc", method.TypeParameters.Count);
properties.Add("tprm", new JArray(method.TypeParameters.Select(tp => tp.Name).ToArray()));
}
string sname;
if (method.IsAccessor)
{
if (method.AccessorOwner is IProperty)
{
sname = Helpers.GetPropertyRef(method.AccessorOwner, emitter, ((IProperty)method.AccessorOwner).Setter == method);
}
else if (method.AccessorOwner is IEvent)
{
sname = Helpers.GetEventRef(method.AccessorOwner, emitter, ((IEvent)method.AccessorOwner).RemoveAccessor == method);
}
else
{
sname = OverloadsCollection.Create(emitter, method).GetOverloadName();
}
}
else
{
sname = OverloadsCollection.Create(emitter, method).GetOverloadName();
}
properties.Add("sn", sname);
}
properties.Add("rt", new JRaw(MetadataUtils.GetTypeName(method.ReturnType, emitter, isGenericSpecialization)));
var attr = MetadataUtils.GetScriptableAttributes(method.ReturnTypeAttributes, emitter, tree).ToList();
if (attr.Count > 0)
{
JArray attrArr = new JArray();
foreach (var a in attr)
{
attrArr.Add(MetadataUtils.ConstructAttribute(a, null, emitter));
}
properties.Add("rta", attrArr);
}
if (method.Parameters.Count > 0)
{
properties.Add("p", new JArray(method.Parameters.Select(p => new JRaw(MetadataUtils.GetTypeName(p.Type, emitter, isGenericSpecialization)))));
}
}
else if (m is IField)
{
var field = (IField)m;
properties.Add("t", (int)MemberTypes.Field);
properties.Add("rt", new JRaw(MetadataUtils.GetTypeName(field.ReturnType, emitter, isGenericSpecialization)));
properties.Add("sn", OverloadsCollection.Create(emitter, field).GetOverloadName());
if (field.IsReadOnly)
{
properties.Add("ro", field.IsReadOnly);
}
}
else if (m is IProperty)
{
var prop = (IProperty)m;
properties.Add("t", (int)MemberTypes.Property);
properties.Add("rt", new JRaw(MetadataUtils.GetTypeName(prop.ReturnType, emitter, isGenericSpecialization)));
if (prop.Parameters.Count > 0)
{
properties.Add("p", new JArray(prop.Parameters.Select(p => new JRaw(MetadataUtils.GetTypeName(p.Type, emitter, isGenericSpecialization)))));
}
if (prop.IsIndexer)
{
properties.Add("i", true);
}
if (prop.IsIndexer)
{
if (prop.Getter != null)
{
var parametersInfo = prop.Getter.Parameters.Select(p => MetadataUtils.ConstructParameterInfo(p, emitter, false, false, tree)).ToList();
if (parametersInfo.Count > 0)
{
properties.Add("ipi", new JArray(parametersInfo));
}
}
else if (prop.Setter != null)
{
var parametersInfo = prop.Setter.Parameters.Take(prop.Setter.Parameters.Count - 1).Select(p => MetadataUtils.ConstructParameterInfo(p, emitter, false, false, tree)).ToList();
if (parametersInfo.Count > 0)
{
properties.Add("ipi", new JArray(parametersInfo));
}
}
}
var inlineGetter = prop.CanGet && (emitter.GetInline(prop.Getter) != null || Helpers.IsScript(prop.Getter));
var inlineSetter = prop.CanSet && (emitter.GetInline(prop.Setter) != null || Helpers.IsScript(prop.Setter));
if (inlineGetter || inlineSetter || prop.IsIndexer)
{
if (prop.CanGet)
{
properties.Add("g", MetadataUtils.ConstructMemberInfo(prop.Getter, emitter, includeDeclaringType, isGenericSpecialization, tree));
}
if (prop.CanSet)
{
properties.Add("s", MetadataUtils.ConstructMemberInfo(prop.Setter, emitter, includeDeclaringType, isGenericSpecialization, tree));
}
}
else
{
var fieldName = OverloadsCollection.Create(emitter, prop).GetOverloadName();
if (prop.CanGet)
{
properties.Add("g", MetadataUtils.ConstructFieldPropertyAccessor(prop.Getter, emitter, fieldName, true, includeDeclaringType, isGenericSpecialization, tree));
}
if (prop.CanSet)
{
properties.Add("s", MetadataUtils.ConstructFieldPropertyAccessor(prop.Setter, emitter, fieldName, false, includeDeclaringType, isGenericSpecialization, tree));
}
properties.Add("fn", fieldName);
}
}
else if (m is IEvent)
{
var evt = (IEvent)m;
properties.Add("t", (int)MemberTypes.Event);
properties.Add("ad", MetadataUtils.ConstructMemberInfo(evt.AddAccessor, emitter, includeDeclaringType, isGenericSpecialization, tree));
properties.Add("r", MetadataUtils.ConstructMemberInfo(evt.RemoveAccessor, emitter, includeDeclaringType, isGenericSpecialization, tree));
}
else
{
throw new ArgumentException("Invalid member " + m);
}
return(properties);
}
public static JObject ConstructTypeMetadata(ITypeDefinition type, IEmitter emitter, bool ifHasAttribute, SyntaxTree tree)
{
var properties = ifHasAttribute ? new JObject() : MetadataUtils.GetCommonTypeProperties(type, emitter);
var scriptableAttributes = MetadataUtils.GetScriptableAttributes(type.Attributes, emitter, tree).ToList();
if (scriptableAttributes.Count != 0)
{
JArray attrArr = new JArray();
foreach (var a in scriptableAttributes)
{
attrArr.Add(MetadataUtils.ConstructAttribute(a, type, emitter));
}
properties.Add("at", attrArr);
}
if (type.Kind == TypeKind.Class || type.Kind == TypeKind.Struct || type.Kind == TypeKind.Interface || type.Kind == TypeKind.Enum)
{
var members = type.Members.Where(m => MetadataUtils.IsReflectable(m, emitter, ifHasAttribute, tree))
.OrderBy(m => m, MemberOrderer.Instance)
.Select(m => MetadataUtils.ConstructMemberInfo(m, emitter, false, false, tree))
.ToList();
if (members.Count > 0)
{
properties.Add("m", new JArray(members));
}
var aua = type.Attributes.FirstOrDefault(a => a.AttributeType.FullName == "System.AttributeUsageAttribute");
if (aua != null)
{
var inherited = true;
var allowMultiple = false;
if (aua.PositionalArguments.Count == 3)
{
allowMultiple = (bool)aua.PositionalArguments[1].ConstantValue;
inherited = (bool)aua.PositionalArguments[2].ConstantValue;
}
if (aua.NamedArguments.Count > 0)
{
foreach (var arg in aua.NamedArguments)
{
if (arg.Key.Name == "AllowMultiple")
{
allowMultiple = (bool)arg.Value.ConstantValue;
}
else if (arg.Key.Name == "Inherited")
{
inherited = (bool)arg.Value.ConstantValue;
}
}
}
if (!inherited)
{
properties.Add("ni", true);
}
if (allowMultiple)
{
properties.Add("am", true);
}
}
}
return(properties.Count > 0 ? properties : null);
}
