private static string GetNewFieldName(IFieldSymbol fieldSymbol)
            {
                var name = fieldSymbol.Name.Trim('_');
                if (name.Length > 2 && char.IsLetter(name[0]) && name[1] == '_')
                {
                    name = name.Substring(2);
                }

                if (name.Length == 0)
                {
                    return fieldSymbol.Name;
                }

                if (name.Length > 2 && char.IsUpper(name[0]) && char.IsLower(name[1]))
                {
                    name = char.ToLower(name[0]) + name.Substring(1);
                }

                if ((fieldSymbol.IsStatic && fieldSymbol.IsReadOnly) || fieldSymbol.IsConst)
                {
                    return ToUppercaseWords(name);
                }

                return "_" + name;
            }

 private static bool ContainingTypeImplementsIDisposableAndCallsItOnTheField(SymbolAnalysisContext context, IFieldSymbol fieldSymbol)
 {
     var containingType = fieldSymbol.ContainingType;
     if (containingType == null) return false;
     var iDisposableInterface = containingType.AllInterfaces.FirstOrDefault(i => i.ToString() == "System.IDisposable");
     if (iDisposableInterface == null) return false;
     var disposableMethod = iDisposableInterface.GetMembers("Dispose").OfType<IMethodSymbol>().First(d => d.Arity == 0);
     var disposeMethodSymbol = containingType.FindImplementationForInterfaceMember(disposableMethod) as IMethodSymbol;
     if (disposeMethodSymbol == null) return false;
     if (disposeMethodSymbol.IsAbstract) return true;
     foreach (MethodDeclarationSyntax disposeMethod in disposeMethodSymbol.DeclaringSyntaxReferences.Select(sr => sr.GetSyntax()))
     {
         if (disposeMethod == null) return false;
         var semanticModel = context.Compilation.GetSemanticModel(disposeMethod.SyntaxTree);
         if (CallsDisposeOnField(fieldSymbol, disposeMethod, semanticModel)) return true;
         var invocations = disposeMethod.DescendantNodes().OfKind<InvocationExpressionSyntax>(SyntaxKind.InvocationExpression);
         foreach (var invocation in invocations)
         {
             var invocationExpressionSymbol = semanticModel.GetSymbolInfo(invocation.Expression).Symbol;
             if (invocationExpressionSymbol == null
                 || invocationExpressionSymbol.Kind != SymbolKind.Method
                 || invocationExpressionSymbol.Locations.Any(l => l.Kind != LocationKind.SourceFile)
                 || !invocationExpressionSymbol.ContainingType.Equals(containingType)) continue;
             foreach (MethodDeclarationSyntax method in invocationExpressionSymbol.DeclaringSyntaxReferences.Select(sr => sr.GetSyntax()))
                 if (CallsDisposeOnField(fieldSymbol, method, semanticModel)) return true;
         }
     }
     return false;
 }

 protected static bool FieldIsRelevant(IFieldSymbol fieldSymbol)
 {
     return fieldSymbol != null &&
            !fieldSymbol.IsStatic &&
            !fieldSymbol.IsConst &&
            fieldSymbol.DeclaredAccessibility == Accessibility.Public;
 }

        private SDField GetParsedField(IFieldSymbol field)
        {
            var syntaxReference = field.DeclaringSyntaxReferences.Any() ? field.DeclaringSyntaxReferences.Single() : null;
            var sdField = new SDField(field.GetIdentifier())
            {
                Name = field.Name,
                DeclaringType = _typeRefParser.GetParsedTypeReference(field.ContainingType),
                Accessibility = field.DeclaredAccessibility.ToString().ToLower(),
                ReturnType = _typeRefParser.GetParsedTypeReference(field.Type),
                ConstantValue = field.ConstantValue != null ? field.ConstantValue.ToString() : string.Empty,
                IsConst = field.IsConst,
                IsReadonly = field.IsReadOnly,
                Documentations = DocumentationParser.ParseDocumentation(field),
                Region = syntaxReference != null ? new SDRegion
                {
                    Start = syntaxReference.Span.Start,
                    End = syntaxReference.Span.End,
                    StartLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).StartLinePosition.Line + 1,
                    EndLine = syntaxReference.SyntaxTree.GetLineSpan(syntaxReference.Span).EndLinePosition.Line + 1,
                    FilePath = syntaxReference.SyntaxTree.FilePath,
                    Filename = Path.GetFileName(syntaxReference.SyntaxTree.FilePath)
                } : null
            };

            ParserOptions.SDRepository.AddMember(sdField);
            return sdField;
        }

            private static string GetNewFieldName(IFieldSymbol fieldSymbol)
            {
                var name = fieldSymbol.Name.Trim('_');
                if (name.Length > 2 && char.IsLetter(name[0]) && name[1] == '_')
                {
                    name = name.Substring(2);
                }

                if (name.Length == 0)
                {
                    return fieldSymbol.Name;
                }

                if (name.Length > 2 && char.IsUpper(name[0]) && char.IsLower(name[1]))
                {
                    name = char.ToLower(name[0]) + name.Substring(1);
                }

                if (fieldSymbol.IsStatic)
                {
                    // Check for ThreadStatic private fields.
                    if (fieldSymbol.GetAttributes().Any(a => a.AttributeClass.Name.Equals("ThreadStaticAttribute", StringComparison.Ordinal)))
                    {
                        return "t_" + name;
                    }
                    else
                    {
                        return "s_" + name;
                    }
                }

                return "_" + name;
            }

        internal static EnumDeclarationSyntax AddEnumMemberTo(EnumDeclarationSyntax destination, IFieldSymbol enumMember, CodeGenerationOptions options)
        {
            var members = new List<SyntaxNodeOrToken>();
            members.AddRange(destination.Members.GetWithSeparators());

            var member = GenerateEnumMemberDeclaration(enumMember, destination, options);

            if (members.Count == 0)
            {
                members.Add(member);
            }
            else if (members.LastOrDefault().CSharpKind() == SyntaxKind.CommaToken)
            {
                members.Add(member);
                members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
            }
            else
            {
                var lastMember = members.Last();
                var trailingTrivia = lastMember.GetTrailingTrivia();
                members[members.Count - 1] = lastMember.WithTrailingTrivia();
                members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(trailingTrivia));
                members.Add(member);
            }

            return destination.EnsureOpenAndCloseBraceTokens()
                .WithMembers(SyntaxFactory.SeparatedList<EnumMemberDeclarationSyntax>(members));
        }

 private static bool FieldIsRelevant(IFieldSymbol fieldSymbol)
 {
     return fieldSymbol != null &&
            fieldSymbol.IsStatic &&
            !fieldSymbol.IsConst &&
            !fieldSymbol.IsReadOnly &&
            fieldSymbol.DeclaredAccessibility != Accessibility.Private;
 }

 public static void Attach(
     IFieldSymbol field,
     bool isUnsafe,
     bool isWithEvents,
     SyntaxNode initializer)
 {
     var info = new CodeGenerationFieldInfo(isUnsafe, isWithEvents, initializer);
     fieldToInfoMap.Add(field, info);
 }

 /// <summary>
 /// Creates a field declaration matching an existing field symbol.
 /// </summary>
 public SyntaxNode FieldDeclaration(IFieldSymbol field, SyntaxNode initializer = null)
 {
     return FieldDeclaration(
         field.Name,
         TypeExpression(field.Type),
         field.DeclaredAccessibility,
         SymbolModifiers.From(field),
         initializer);
 }

        private SyntaxNode GetExplicitlyAssignedField(IFieldSymbol originalField, SyntaxNode declaration, SyntaxGenerator generator)
        {
            SyntaxNode originalInitializer = generator.GetExpression(declaration);
            if (originalInitializer != null || !originalField.HasConstantValue)
            {
                return declaration;
            }

            return generator.WithExpression(declaration, generator.LiteralExpression(originalField.ConstantValue));
        }

        private bool IsParentAClass(IFieldSymbol fieldDeclarationSyntax)
        {
            if (fieldDeclarationSyntax.ContainingSymbol != null &&
                fieldDeclarationSyntax.ContainingSymbol.Kind == SymbolKind.NamedType)
            {
                return ((ITypeSymbol)fieldDeclarationSyntax.ContainingSymbol).TypeKind == TypeKind.Class;
            }

            return false;
        }

        private IEnumerable<EncapsulateFieldCodeAction> EncapsulateOneField(Document document, TextSpan span, IFieldSymbol field, int index)
        {
            var action1Text = string.Format(FeaturesResources.EncapsulateFieldUsages, field.Name);
            var action2Text = string.Format(FeaturesResources.EncapsulateField, field.Name);

            return new[]
            {
                new EncapsulateFieldCodeAction(new EncapsulateFieldResult(c => SingleEncapsulateFieldResultAsync(document, span, index, true, c)), action1Text),
                new EncapsulateFieldCodeAction(new EncapsulateFieldResult(c => SingleEncapsulateFieldResultAsync(document, span, index, false, c)), action2Text)
            };
        }

        internal override SyntaxNode GetFieldInitializer(IFieldSymbol field)
        {
            if (field.DeclaringSyntaxReferences.Length == 0)
            {
                return null;
            }

            var syntax = field.DeclaringSyntaxReferences.First().GetSyntax();
            var enumMemberSyntax = syntax as EnumMemberDeclarationSyntax;
            return enumMemberSyntax == null ? null : enumMemberSyntax.EqualsValue;
        }

    private static void CheckForDiagnostics(SyntaxNodeAnalysisContext context, FieldDeclarationSyntax fieldNode, IFieldSymbol fieldSymbol)
    {
      var isStatic = fieldSymbol.IsStatic;
      var isPublic = fieldSymbol.DeclaredAccessibility.HasFlag(Accessibility.Public);
      var isReadOnly = fieldSymbol.IsReadOnly;

      if (!isStatic || !isPublic || !isReadOnly)
      {
        context.ReportDiagnostic(Diagnostic.Create(
          EvaluateManagedBackingFieldsAnalayzer.mustBePublicStaticAndReadonlyRule,
          fieldNode.GetLocation()));
      }
    }

        internal static CompilationUnitSyntax AddFieldTo(
            CompilationUnitSyntax destination,
            IFieldSymbol field,
            CodeGenerationOptions options,
            IList<bool> availableIndices)
        {
            var declaration = GenerateFieldDeclaration(field, CodeGenerationDestination.CompilationUnit, options);

            // Place the field after the last field or const, or at the start of the type
            // declaration.
            var members = Insert(destination.Members, declaration, options, availableIndices,
                after: m => LastField(m, declaration), before: FirstMember);
            return destination.WithMembers(members.ToSyntaxList());
        }

        private IFieldSymbol GetExplicitlyAssignedField(IFieldSymbol originalField, SyntaxGenerator syntaxFactoryService)
        {
            var originalInitializer = GetFieldInitializer(originalField);
            if (originalInitializer != null || !originalField.HasConstantValue)
            {
                return originalField;
            }

            var constantValueExpression = syntaxFactoryService.LiteralExpression(originalField.ConstantValue);
            var newInitializer = CreateConstantValueInitializer(constantValueExpression);

            return CodeGenerationSymbolFactory.CreateFieldSymbol(originalField.GetAttributes(), originalField.DeclaredAccessibility, originalField.GetSymbolModifiers(),
                originalField.Type, originalField.Name, originalField.HasConstantValue, originalField.ConstantValue, newInitializer);
        }

 private static bool CallsDisposeOnField(IFieldSymbol fieldSymbol, MethodDeclarationSyntax disposeMethod, SemanticModel semanticModel)
 {
     var hasDisposeCall = disposeMethod.Body.Statements.OfType<ExpressionStatementSyntax>()
         .Any(exp =>
         {
             var invocation = exp.Expression as InvocationExpressionSyntax;
             if (!invocation?.Expression?.IsKind(SyntaxKind.SimpleMemberAccessExpression) ?? true) return false;
             var memberAccess = (MemberAccessExpressionSyntax)invocation.Expression;
             if (memberAccess.Name.Identifier.ToString() != "Dispose" || memberAccess.Name.Arity != 0) return false;
             var memberAccessIdentificer = memberAccess.Expression as IdentifierNameSyntax;
             if (memberAccessIdentificer == null) return false;
             return fieldSymbol.Equals(semanticModel.GetSymbolInfo(memberAccessIdentificer).Symbol);
         });
     return hasDisposeCall;
 }

        private static void AddVariableThatWasSkippedBeforeBecauseItLackedAInitializer(Dictionary<IFieldSymbol, VariableDeclaratorSyntax> variablesToMakeReadonly, IFieldSymbol fieldSymbol, AssignmentExpressionSyntax assignment)
        {
            var parent = assignment.Parent;
            while (parent != null)
            {
                if (parent is AnonymousFunctionExpressionSyntax)
                    return;
                if (parent is ConstructorDeclarationSyntax)
                    break;
                parent = parent.Parent;
            }

            if (!fieldSymbol.IsReadOnly && !variablesToMakeReadonly.Keys.Contains(fieldSymbol))
                foreach (var variable in fieldSymbol.DeclaringSyntaxReferences)
                    variablesToMakeReadonly.Add(fieldSymbol, (VariableDeclaratorSyntax)variable.GetSyntax());
        }

        private SDField GetParsedField(IFieldSymbol field)
        {
            var sdField = new SDField(field.GetIdentifier())
            {
                Name = field.Name,
                DeclaringType = _typeRefParser.GetParsedTypeReference(field.ContainingType),
                Accessibility = field.DeclaredAccessibility.ToString().ToLower(),
                ReturnType = _typeRefParser.GetParsedTypeReference(field.Type),
                ConstantValue = field.ConstantValue != null ? field.ConstantValue.ToString() : string.Empty,
                IsConst = field.IsConst,
                IsReadonly = field.IsReadOnly,
                Documentations = DocumentationParser.ParseDocumentation(field)
            };

            ParserOptions.SDRepository.AddMember(sdField);
            return sdField;
        }

		public static string GetWidgetFieldName (IFieldSymbol field)
		{
			foreach (AttributeData att in field.GetAttributes ())	{
				var type = att.AttributeClass;
				if (type.Name == "Widget" ||  type.Name == "WidgetAttribute") {
					var pArgs = att.ConstructorArguments;
					if (pArgs != null && pArgs.Length > 0) {
						var exp = pArgs[0].Value;
						if (exp != null)
							return exp.ToString ();
					} else {
						return field.Name;
					}
				}
			}
			return field.Name;
		}