Пример #1
0
        private static AttributeData GetInheritedAttribute(ISymbol symbol, string attrName)
        {
            foreach (var attr in symbol.GetAttributes())
            {
                if (attr.AttributeClass.FullyQualifiedName() == attrName)
                {
                    return(attr);
                }
            }

            var method = symbol as IMethodSymbol;

            if (method != null && method.OverriddenMethod != null)
            {
                return(SyntaxHelper.GetInheritedAttribute(method.OverriddenMethod, attrName));
            }

            var property = symbol as IPropertySymbol;

            if (property != null && property.OverriddenProperty != null)
            {
                return(SyntaxHelper.GetInheritedAttribute(property.OverriddenProperty, attrName));
            }

            return(null);
        }
Пример #2
0
        public static string GetSymbolName(InvocationExpressionSyntax node, SymbolInfo si, string name, SemanticModel semanticModel)
        {
            var symbol = si.Symbol;

            if (symbol == null && si.CandidateSymbols.Any())
            {
                symbol = si.CandidateSymbols.First();
            }

            if (symbol != null && symbol.Kind != SymbolKind.Namespace)
            {
                //bool preserveMemberChange = !(symbol.Kind == SymbolKind.Method || symbol.Kind == SymbolKind.Property);

                int enumMode = -1;

                if (symbol.ContainingType != null && symbol.ContainingType.TypeKind == TypeKind.Enum && symbol is IFieldSymbol)
                {
                    string enumAttr = Translator.Bridge_ASSEMBLY + ".EnumAttribute";
                    enumMode = 7;

                    foreach (var attr in symbol.ContainingType.GetAttributes())
                    {
                        if (attr.AttributeClass != null && attr.AttributeClass.FullyQualifiedName() == enumAttr && attr.ConstructorArguments.Any())
                        {
                            enumMode = (int)attr.ConstructorArguments.First().Value;
                            break;
                        }
                    }
                }

                var  nameAttr = SyntaxHelper.GetInheritedAttribute(symbol, Bridge.Translator.Translator.Bridge_ASSEMBLY + ".NameAttribute");
                bool isIgnore = symbol.ContainingType != null && SyntaxHelper.IsExternalType(symbol.ContainingType);

                name = symbol.Name;

                if (nameAttr != null)
                {
                    var value = nameAttr.ConstructorArguments.First().Value;
                    if (value is string)
                    {
                        name = value.ToString();
                        name = Helpers.ConvertNameTokens(name, symbol.Name);
                        if (!isIgnore && symbol.IsStatic && Helpers.IsReservedStaticName(name))
                        {
                            name = Helpers.ChangeReservedWord(name);
                        }
                        return(name);
                    }

                    //preserveMemberChange = !(bool)value;
                    enumMode = -1;
                }

                if (enumMode > 6)
                {
                    switch (enumMode)
                    {
                    case 7:
                        break;

                    case 8:
                        name = name.ToLowerInvariant();
                        break;

                    case 9:
                        name = name.ToUpperInvariant();
                        break;
                    }
                }

                /*else
                 * {
                 *  name = !preserveMemberChange ? Object.Net.Utilities.StringUtils.ToLowerCamelCase(name) : name;
                 * }*/

                if (!isIgnore && symbol.IsStatic && Helpers.IsReservedStaticName(name))
                {
                    name = Helpers.ChangeReservedWord(name);
                }
            }

            return(name);
        }