C# Syntax.FieldDeclarationSyntax类代码示例

        /// <summary>
        /// Creates a field that holds <see cref="QueryTypeProperties{T}"/> for the module.
        /// </summary>
        protected FieldDeclarationSyntax CreatePropertiesField(
            Module module, string resultClassName, FieldDeclarationSyntax propsField, SortType? sortType)
        {
            var queryTypePropertiesType = SyntaxEx.GenericName("QueryTypeProperties", resultClassName);

            var propertiesInitializer = SyntaxEx.ObjectCreation(
                queryTypePropertiesType,
                SyntaxEx.Literal(module.Name),
                SyntaxEx.Literal(module.Prefix),
                module.QueryType == null
                    ? (ExpressionSyntax)SyntaxEx.NullLiteral()
                    : SyntaxEx.MemberAccess("QueryType", module.QueryType.ToString()),
                sortType == null
                    ? (ExpressionSyntax)SyntaxEx.NullLiteral()
                    : SyntaxEx.MemberAccess("SortType", sortType.ToString()),
                CreateTupleListExpression(GetBaseParameters(module)),
                propsField == null ? (ExpressionSyntax)SyntaxEx.NullLiteral() : (NamedNode)propsField,
                resultClassName == "object"
                    ? (ExpressionSyntax)SyntaxEx.LambdaExpression("_", SyntaxEx.NullLiteral())
                    : SyntaxEx.MemberAccess(resultClassName, "Parse"));

            return SyntaxEx.FieldDeclaration(
                new[] { SyntaxKind.PrivateKeyword, SyntaxKind.StaticKeyword, SyntaxKind.ReadOnlyKeyword },
                queryTypePropertiesType, ClassNameBase + "Properties", propertiesInitializer);
        }

 public static string GetFieldName(FieldDeclarationSyntax field)
 {
     var variable = field.Declaration.Variables.FirstOrDefault(); //.DescendantNodes().Where(e => e.IsKind(SyntaxKind.IdentifierToken)).Last().Span.ToString();
     if (variable == null)
         return "";
     return variable.Identifier.ToString();
 }

            public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
            {
                bool isInstance;
                if (NeedsRewrite(node, out isInstance))
                {
                    var list = new List<VariableDeclaratorSyntax>(node.Declaration.Variables.Count);
                    foreach (var v in node.Declaration.Variables)
                    {
                        if (IsGoodPrivateFieldName(v.Identifier.Text, isInstance))
                        {
                            list.Add(v);
                        }
                        else
                        {
                            list.Add(v.WithAdditionalAnnotations(s_markerAnnotation));
                            _count++;
                        }
                    }

                    var declaration = node.Declaration.WithVariables(SyntaxFactory.SeparatedList(list));
                    node = node.WithDeclaration(declaration);

                    return node;
                }

                return node;
            }

 public FieldDeclarationTranslation(FieldDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
 {
     Declaration = syntax.Declaration.Get<VariableDeclarationTranslation>(this);
     Declaration.ExcludeVar = true;
     Modifiers = syntax.Modifiers.Get(this);
     Modifiers.ConstantToStatic = true;                     
 }

 public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
 {
     if (_fieldsToRemove.Contains(node.GetText().ToString()))
     {
         return null;
     }
     return base.VisitFieldDeclaration(node);
 }

        private async Task<Document> AddReadonlyModifier(Document document, SyntaxNode root, FieldDeclarationSyntax fieldDeclaration, CancellationToken cancellationToken)
        {
            var docEditor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
            var modifiers = docEditor.Generator.GetModifiers(fieldDeclaration);
            docEditor.SetModifiers(fieldDeclaration, modifiers + DeclarationModifiers.ReadOnly);

            return docEditor.GetChangedDocument();
        }

        public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
        {
            string visibility = GetVisibilityModifier(node.Modifiers);

            foreach (var identifier in node.Declaration.Variables)
            {
                Emit(string.Format("{0} {1}: {2};", visibility, identifier.GetText(), GetMappedType(node.Declaration.Type)));
            }
        }

 private static SyntaxNode MakeSingleFieldReadonly(SyntaxNode root, FieldDeclarationSyntax fieldDeclaration)
 {
     var newFieldDeclaration = fieldDeclaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))
         .WithTrailingTrivia(fieldDeclaration.GetTrailingTrivia())
         .WithLeadingTrivia(fieldDeclaration.GetLeadingTrivia())
         .WithAdditionalAnnotations(Formatter.Annotation);
     var newRoot = root.ReplaceNode(fieldDeclaration, newFieldDeclaration);
     return newRoot;
 }

 public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
 {
     base.VisitFieldDeclaration(node);
     foreach (var variable in node.Declaration.Variables)
     {
         var test = variable.Identifier;
         DefinedOutside.Add(variable.Identifier.ToString(), variable.ToFullString());
     }
     var t = DefinedOutside;
 }

        public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
        {
            string type = node.Declaration.Type.ToString();
            foreach (Variable var in node.Declaration.Variables.Select(val => new Variable() { Name = val.Identifier.ToString(), Type = type }))
            {
                this.Variables.Add(var);
            }

            base.VisitFieldDeclaration(node);
        }

 public static void Go(OutputWriter writer, FieldDeclarationSyntax field)
 {
     foreach (var declaration in field.Declaration.Variables)
     {
       
         //TODO: Add support for threadstatic
         Go(writer, field, field.Modifiers,
             WriteIdentifierName.TransformIdentifier(declaration.Identifier.Text), field.Declaration.Type,
             declaration.Initializer,field.IsThreadStatic());
     }
 }

        private static void CaptureCandidateFields(FieldDeclarationSyntax field, SemanticModel semanticModel, List<FieldCandidate> candidateFields)
        {

            if (!CanBecameReadOnlyField(field)) return;
            var variables = field.Declaration.Variables;
            var currentAnalysisCandidateFields = variables.Select(s => new FieldCandidate { Variable = s, FieldSymbol = semanticModel.GetDeclaredSymbol(s) as IFieldSymbol })
                .Where(p => p.FieldSymbol != null && p.FieldSymbol.ContainingType != null);

            if (!currentAnalysisCandidateFields.Any()) return;
            candidateFields.AddRange(currentAnalysisCandidateFields);
        }

        private async Task<Document> MakeReadOnlyAsync(Document document, FieldDeclarationSyntax fieldDecl, CancellationToken cancellationToken)
        {
            var roKeyword = SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword);
            var roFieldDecl = fieldDecl.AddModifiers(roKeyword);

            var root = await document.GetSyntaxRootAsync(cancellationToken);
            var newRoot = root.ReplaceNode(fieldDecl, roFieldDecl);

            var newDocument = document.WithSyntaxRoot(newRoot);
            return newDocument;
        }

 private static SyntaxNode MakeMultipleFieldsReadonly(SyntaxNode root, FieldDeclarationSyntax fieldDeclaration, VariableDeclaratorSyntax variableToMakeReadonly)
 {
     var newDeclaration = fieldDeclaration.Declaration.RemoveNode(variableToMakeReadonly, SyntaxRemoveOptions.KeepEndOfLine);
     var newFieldDeclaration = fieldDeclaration.WithDeclaration(newDeclaration);
     var newReadonlyFieldDeclaration = fieldDeclaration.WithDeclaration(SyntaxFactory.VariableDeclaration(fieldDeclaration.Declaration.Type, SyntaxFactory.SeparatedList(new[] { variableToMakeReadonly })))
         .WithoutLeadingTrivia()
         .WithTrailingTrivia(SyntaxFactory.ParseTrailingTrivia("\n"))
         .AddModifiers(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))
         .WithAdditionalAnnotations(Formatter.Annotation);
     var newRoot = root.ReplaceNode(fieldDeclaration, new[] { newFieldDeclaration, newReadonlyFieldDeclaration });
     return newRoot;
 }

        public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax field)
        {
            // Retrieve the symbol for the field's variable
            if (field.Declaration.Variables.Count == 1)
            {
                if (object.Equals(semanticModel.GetDeclaredSymbol(field.Declaration.Variables.First()), backingField))
                {
                    return null;
                }
            }

            return field;
        }