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); }