public static IAttribute GetInheritedAttribute(IMember member, string attrName)
{
foreach (var attr in member.Attributes)
{
if (attr.AttributeType.FullName == attrName)
{
return attr;
}
}
if (member.IsOverride)
{
member = InheritanceHelper.GetBaseMember(member);
if (member != null)
{
return Helpers.GetInheritedAttribute(member, attrName);
}
}
else if (member.ImplementedInterfaceMembers != null && member.ImplementedInterfaceMembers.Count > 0)
{
foreach (var interfaceMember in member.ImplementedInterfaceMembers)
{
var attr = Helpers.GetInheritedAttribute(interfaceMember, attrName);
if (attr != null)
{
return attr;
}
}
}
return null;
}
public static CustomAttribute GetInheritedAttribute(IEmitter emitter, IMemberDefinition member, string attrName)
{
foreach (var attr in member.CustomAttributes)
{
if (attr.AttributeType.FullName == attrName)
{
return attr;
}
}
var methodDefinition = member as MethodDefinition;
if (methodDefinition != null)
{
var isOverride = methodDefinition.IsVirtual && methodDefinition.IsReuseSlot;
if (isOverride)
{
member = Helpers.GetBaseMethod(methodDefinition, emitter);
if (member != null)
{
return Helpers.GetInheritedAttribute(emitter, member, attrName);
}
}
}
return null;
}
private static List <NameRule> GetSpecialRules(NameSemantic semantic)
{
var rules = new List <NameRule>();
var nameAttr = Helpers.GetInheritedAttribute(semantic.Entity, "Bridge.NameAttribute");
if (nameAttr != null)
{
var rule = new NameRule();
rule.Level = NameRuleLevel.Member;
var value = nameAttr.PositionalArguments.First().ConstantValue;
if (value is bool)
{
rule.Notation = (bool)value ? Notation.CamelCase : Notation.None;
}
else if (value is string)
{
rule.CustomName = (string)value;
}
semantic.IsCustomName = true;
rules.Add(rule);
}
else
{
var method = semantic.Entity as IMethod;
if (method != null && method.IsConstructor)
{
semantic.IsCustomName = true;
rules.Add(NameConvertor.ConstructorRule);
}
}
return(rules);
}
protected virtual string GetOverloadName(IMember definition)
{
string name = this.Emitter.GetEntityName(definition, this.CancelChangeCase);
if (name.StartsWith(".ctor"))
{
name = "constructor";
}
var attr = Helpers.GetInheritedAttribute(definition, "Bridge.NameAttribute");
if (attr == null && definition is IProperty)
{
var prop = (IProperty)definition;
var acceessor = this.IsSetter ? prop.Setter : prop.Getter;
if (acceessor != null)
{
attr = Helpers.GetInheritedAttribute(acceessor, "Bridge.NameAttribute");
}
}
if (attr != null || (definition.DeclaringTypeDefinition != null && definition.DeclaringTypeDefinition.Kind != TypeKind.Interface && this.Emitter.Validator.IsIgnoreType(definition.DeclaringTypeDefinition)))
{
return(name);
}
if (definition is IMethod && ((IMethod)definition).IsConstructor)
{
name = "constructor";
}
var index = this.GetIndex(definition);
if (index > 0)
{
name += "_" + index;
if (name.StartsWith("_"))
{
name = name.Substring(1);
}
}
if (definition.ImplementedInterfaceMembers.Count > 0)
{
foreach (var iMember in definition.ImplementedInterfaceMembers)
{
if (OverloadsCollection.Create(this.Emitter, iMember, false, true).GetOverloadName() != name)
{
string message = "Cannot translate interface ({2}) member '{0}' in '{1}' due name conflicts. Please rename methods or refactor your code";
throw new Exception(string.Format(message, definition.ToString(), definition.DeclaringType.ToString(), iMember.DeclaringType.ToString()));
}
}
}
return(name);
}
public static IAttribute GetInheritedAttribute(IEntity entity, string attrName)
{
if (entity is IMember)
{
return Helpers.GetInheritedAttribute((IMember)entity, attrName);
}
foreach (var attr in entity.Attributes)
{
if (attr.AttributeType.FullName == attrName)
{
return attr;
}
}
return null;
}
public static IAttribute GetInheritedAttribute(ITypeDefinition typeDef, string attrName)
{
foreach (var attr in typeDef.Attributes)
{
if (attr.AttributeType.FullName == attrName)
{
return(attr);
}
}
var baseType = typeDef.DirectBaseTypes.Where(t => t.Kind != TypeKind.Interface).FirstOrDefault();
if (baseType != null)
{
return(Helpers.GetInheritedAttribute(baseType.GetDefinition(), attrName));
}
return(null);
}
public static IAttribute GetInheritedAttribute(IMember member, string attrName)
{
foreach (var attr in member.Attributes)
{
if (attr.AttributeType.FullName == attrName)
{
return(attr);
}
}
if (member.IsOverride)
{
member = InheritanceHelper.GetBaseMember(member);
if (member != null)
{
return(Helpers.GetInheritedAttribute(member, attrName));
}
}
return(null);
}
protected virtual string GetOverloadName(IMember definition, bool skipInterfaceName = false, string prefix = null, bool withoutTypeParams = false)
{
IMember interfaceMember = null;
if (definition.IsExplicitInterfaceImplementation)
{
interfaceMember = definition.ImplementedInterfaceMembers.First();
}
else if (definition.DeclaringTypeDefinition != null && definition.DeclaringTypeDefinition.Kind == TypeKind.Interface)
{
interfaceMember = definition;
}
if (interfaceMember != null && !skipInterfaceName && !this.Emitter.Validator.IsObjectLiteral(interfaceMember.DeclaringTypeDefinition))
{
return(OverloadsCollection.GetInterfaceMemberName(this.Emitter, interfaceMember, null, prefix, withoutTypeParams, this.IsSetter));
}
string name = this.Emitter.GetEntityName(definition, this.CancelChangeCase);
if (name.StartsWith("." + JS.Funcs.CONSTRUCTOR))
{
name = JS.Funcs.CONSTRUCTOR;
}
var attr = Helpers.GetInheritedAttribute(definition, "Bridge.NameAttribute");
var iProperty = definition as IProperty;
if (attr == null && iProperty != null && !IsField)
{
var acceessor = this.IsSetter ? iProperty.Setter : iProperty.Getter;
if (acceessor != null)
{
attr = Helpers.GetInheritedAttribute(acceessor, "Bridge.NameAttribute");
}
}
if (attr != null)
{
var value = attr.PositionalArguments.First().ConstantValue;
if (value is string)
{
name = value.ToString();
}
if (!(iProperty != null || definition is IEvent))
{
prefix = null;
}
}
if (attr != null && definition.ImplementedInterfaceMembers.Count > 0)
{
if (this.Members.Where(member => member.ImplementedInterfaceMembers.Count > 0)
.Any(member => definition.ImplementedInterfaceMembers.Any(implementedInterfaceMember => member.ImplementedInterfaceMembers.Any(m => m.DeclaringTypeDefinition == implementedInterfaceMember.DeclaringTypeDefinition))))
{
attr = null;
}
}
bool skipSuffix = false;
if (definition.DeclaringTypeDefinition != null &&
this.Emitter.Validator.IsExternalType(definition.DeclaringTypeDefinition))
{
if (definition.DeclaringTypeDefinition.Kind == TypeKind.Interface)
{
skipSuffix = definition.DeclaringTypeDefinition.ParentAssembly.AssemblyName != CS.NS.ROOT;
}
else
{
skipSuffix = true;
}
}
if (attr != null || skipSuffix)
{
return(prefix != null ? prefix + name : name);
}
var iDefinition = definition as IMethod;
var isCtor = iDefinition != null && iDefinition.IsConstructor;
if (isCtor)
{
name = JS.Funcs.CONSTRUCTOR;
}
var index = this.GetIndex(definition);
if (index > 0)
{
if (isCtor)
{
name = JS.Vars.D + name + index;
}
else
{
name += Helpers.PrefixDollar(index);
name = Helpers.ReplaceFirstDollar(name);
}
}
return(prefix != null ? prefix + name : name);
}
public static CompilerRule Get(IEmitter emitter, IEntity entity)
{
CompilerRule memberRule = null;
CompilerRule[] classRules = null;
CompilerRule[] assemblyRules = null;
CompilerRule[] interfaceRules = null;
if (entity is IMember)
{
var attr = Helpers.GetInheritedAttribute(entity, attributeName);
if (attr != null)
{
memberRule = Rules.ToRule(attr, CompilerRuleLevel.Member);
}
var typeDef = entity.DeclaringTypeDefinition;
if (typeDef != null)
{
classRules = Rules.GetClassRules(emitter, typeDef);
}
interfaceRules = Rules.GetVirtualMemberRules(emitter, entity);
}
else if (entity is ITypeDefinition)
{
classRules = Rules.GetClassRules(emitter, (ITypeDefinition)entity);
}
var assembly = entity.ParentAssembly;
if (emitter != null && emitter.AssemblyCompilerRuleCache.ContainsKey(assembly))
{
assemblyRules = emitter.AssemblyCompilerRuleCache[assembly];
}
else
{
IAttribute[] assemblyAttrs = assembly.AssemblyAttributes.Where(a => a.AttributeType.FullName == Rules.attributeName).ToArray();
assemblyRules = new CompilerRule[assemblyAttrs.Length];
for (int i = 0; i < assemblyAttrs.Length; i++)
{
assemblyRules[i] = Rules.ToRule(assemblyAttrs[i], CompilerRuleLevel.Assembly);
}
if (emitter != null)
{
emitter.AssemblyCompilerRuleCache.Add(assembly, assemblyRules);
}
}
var rules = new List <CompilerRule>();
if (memberRule != null)
{
rules.Add(memberRule);
}
if (classRules != null && classRules.Length > 0)
{
rules.AddRange(classRules);
}
if (interfaceRules != null && interfaceRules.Length > 0)
{
rules.AddRange(interfaceRules);
}
if (emitter != null)
{
rules.Add(emitter.AssemblyInfo.Rules);
}
if (assemblyRules != null && assemblyRules.Length > 0)
{
rules.AddRange(assemblyRules);
}
return(MergeRules(rules));
}
protected virtual string GetOverloadName(IMember definition, bool skipInterfaceName = false, string prefix = null, bool withoutTypeParams = false)
{
IMember interfaceMember = null;
if (definition.IsExplicitInterfaceImplementation)
{
interfaceMember = definition.ImplementedInterfaceMembers.First();
}
else if (definition.DeclaringTypeDefinition != null && definition.DeclaringTypeDefinition.Kind == TypeKind.Interface)
{
interfaceMember = definition;
}
if (interfaceMember != null && !skipInterfaceName)
{
return(OverloadsCollection.GetInterfaceMemberName(this.Emitter, interfaceMember, null, prefix, withoutTypeParams, this.IsSetter));
}
string name = this.Emitter.GetEntityName(definition, this.CancelChangeCase);
if (name.StartsWith(".ctor"))
{
name = JS.Funcs.CONSTRUCTOR;
}
var attr = Helpers.GetInheritedAttribute(definition, "Bridge.NameAttribute");
if (attr == null && definition is IProperty)
{
var prop = (IProperty)definition;
var acceessor = this.IsSetter ? prop.Setter : prop.Getter;
if (acceessor != null)
{
attr = Helpers.GetInheritedAttribute(acceessor, "Bridge.NameAttribute");
}
}
if (attr != null)
{
var value = attr.PositionalArguments.First().ConstantValue;
if (value is string)
{
name = value.ToString();
}
prefix = null;
}
if (attr != null && definition.ImplementedInterfaceMembers.Count > 0)
{
if (this.Members.Where(member => member.ImplementedInterfaceMembers.Count > 0)
.Any(member => definition.ImplementedInterfaceMembers.Any(implementedInterfaceMember => member.ImplementedInterfaceMembers.Any(m => m.DeclaringTypeDefinition == implementedInterfaceMember.DeclaringTypeDefinition))))
{
attr = null;
}
}
if (attr != null || (definition.DeclaringTypeDefinition != null && definition.DeclaringTypeDefinition.Kind != TypeKind.Interface && this.Emitter.Validator.IsIgnoreType(definition.DeclaringTypeDefinition)))
{
return(prefix != null ? prefix + name : name);
}
var isCtor = definition is IMethod && ((IMethod)definition).IsConstructor;
if (isCtor)
{
name = JS.Funcs.CONSTRUCTOR;
}
var index = this.GetIndex(definition);
if (index > 0)
{
if (isCtor)
{
name = JS.Vars.D + name + index;
}
else
{
name += Helpers.PrefixDollar(index);
name = Helpers.ReplaceFirstDollar(name);
}
}
return(prefix != null ? prefix + name : name);
}
public static bool IsNonScriptable(IEntity entity)
{
return(Helpers.GetInheritedAttribute(entity, "Bridge.NonScriptableAttribute") != null);
}
public static bool IsNonScriptable(ITypeDefinition type)
{
return(Helpers.GetInheritedAttribute(type, "Bridge.NonScriptableAttribute") != null);
}
private static List <NameRule> GetAttributeRules(NameSemantic semantic)
{
NameRule memberRule = null;
NameRule[] classRules = null;
NameRule[] assemblyRules = null;
NameRule[] interfaceRules = null;
if (semantic.Entity is IMember)
{
var attr = Helpers.GetInheritedAttribute(semantic.Entity, NameConvertor.ConventionAttrName);
if (attr != null)
{
memberRule = NameConvertor.ToRule(attr, NameRuleLevel.Member);
}
var typeDef = semantic.Entity.DeclaringTypeDefinition;
if (typeDef != null)
{
classRules = NameConvertor.GetClassRules(semantic, typeDef);
}
interfaceRules = NameConvertor.GetVirtualMemberRules(semantic);
}
else if (semantic.Entity is ITypeDefinition)
{
classRules = NameConvertor.GetClassRules(semantic, (ITypeDefinition)semantic.Entity);
}
var assembly = semantic.Entity.ParentAssembly;
if (semantic.Emitter.AssemblyNameRuleCache.ContainsKey(assembly))
{
assemblyRules = semantic.Emitter.AssemblyNameRuleCache[assembly];
}
else
{
IAttribute[] assemblyAttrs = assembly.AssemblyAttributes.Where(a => a.AttributeType.FullName == NameConvertor.ConventionAttrName).ToArray();
assemblyRules = new NameRule[assemblyAttrs.Length];
for (int i = 0; i < assemblyAttrs.Length; i++)
{
assemblyRules[i] = NameConvertor.ToRule(assemblyAttrs[i], NameRuleLevel.Assembly);
}
Array.Sort(assemblyRules, (item1, item2) => - item1.Priority.CompareTo(item2.Priority));
semantic.Emitter.AssemblyNameRuleCache.Add(assembly, assemblyRules);
}
var rules = new List <NameRule>();
if (memberRule != null)
{
rules.Add(memberRule);
}
if (classRules != null && classRules.Length > 0)
{
rules.AddRange(classRules);
}
if (interfaceRules != null && interfaceRules.Length > 0)
{
rules.AddRange(interfaceRules);
}
if (assemblyRules != null && assemblyRules.Length > 0)
{
rules.AddRange(assemblyRules);
}
return(rules);
}
