/// <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 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 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 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; }
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 SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node) { if (_fieldsToRemove.Contains(node.GetText().ToString())) { return null; } return base.VisitFieldDeclaration(node); }
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) { 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 glsl.FieldDeclarationSyntax Translate(this cs.FieldDeclarationSyntax node) { return(new glsl.FieldDeclarationSyntax() { Qualifier = node.DescendantNodes().OfType <cs.AttributeSyntax>().Single().Translate(), Type = node.DescendantNodes().OfType <cs.VariableDeclarationSyntax>().Single().Type.Translate(), Identifier = node.DescendantNodes().OfType <cs.VariableDeclarationSyntax>().Single().Variables.Single().Identifier, SemicolonToken = node.SemicolonToken }); }
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; }
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; }
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 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; }
private async Task<Document> MakePrivateDeclarationAsync(Document document, FieldDeclarationSyntax declaration, CancellationToken c) { var accessToken = declaration.ChildTokens() .SingleOrDefault(token => token.Kind() == SyntaxKind.PublicKeyword); var privateAccessToken = SyntaxFactory.Token(SyntaxKind.PrivateKeyword); var root = await document.GetSyntaxRootAsync(c); var newRoot = root.ReplaceToken(accessToken, privateAccessToken); return document.WithSyntaxRoot(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; }
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())); } }
public override VisualBasicSyntaxNode VisitFieldDeclaration(CSS.FieldDeclarationSyntax node) { var modifiers = ConvertModifiers(node.Modifiers, TokenContext.Member); if (modifiers.Count == 0) { modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)); } return(SyntaxFactory.FieldDeclaration( SyntaxFactory.List(node.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(this))), modifiers, RemodelVariableDeclaration(node.Declaration, this) )); }
private async Task<Document> MakePrivateAsync(Document document, FieldDeclarationSyntax fieldDeclaration, CancellationToken cancellationToken) { SyntaxToken privateSyntaxToken = CreatePrivateSyntaxToken(fieldDeclaration); IEnumerable<SyntaxToken> newFieldModifiers = new[] { privateSyntaxToken }.Union( fieldDeclaration.Modifiers.Where(modifier => modifier.Kind() != SyntaxKind.InternalKeyword && modifier.Kind() != SyntaxKind.PublicKeyword) .Select(modifier => modifier.WithLeadingTrivia())); FieldDeclarationSyntax newfieldDeclaration = fieldDeclaration.Update(fieldDeclaration.AttributeLists, new SyntaxTokenList().AddRange(newFieldModifiers), fieldDeclaration.Declaration.WithoutTrivia(), fieldDeclaration.SemicolonToken) .WithLeadingTrivia(fieldDeclaration.GetLeadingTrivia()) .WithTrailingTrivia(fieldDeclaration.GetTrailingTrivia()); return await this.ReplaceNodeInDocumentAsync(document, cancellationToken, fieldDeclaration, newfieldDeclaration); }
private static MemberDeclarationSyntax LastField( SyntaxList<MemberDeclarationSyntax> members, FieldDeclarationSyntax fieldDeclaration) { var lastConst = members.AsEnumerable() .OfType<FieldDeclarationSyntax>() .Where(f => f.Modifiers.Any(SyntaxKind.ConstKeyword)).LastOrDefault(); // Place a const after the last existing const. if (fieldDeclaration.Modifiers.Any(SyntaxKind.ConstKeyword)) { return lastConst; } // Place a field after the last field, or after the last const. return LastField(members) ?? lastConst; }
private static bool NeedsRewrite(FieldDeclarationSyntax fieldSyntax, out bool isInstance) { if (!IsPrivateField(fieldSyntax, out isInstance)) { return false; } foreach (var v in fieldSyntax.Declaration.Variables) { if (!IsGoodPrivateFieldName(v.Identifier.ValueText, isInstance)) { return true; } } return false; }
public static string GetMemberSymbolName(this SemanticModel model, FieldDeclarationSyntax syntax) { var attrDeclares = syntax.AttributeLists; foreach (var attrDeclare in attrDeclares) { foreach (var attr in attrDeclare.Attributes) { var type = model.GetTypeInfo(attr); if (type.Type.IsSameType(nameof(JavaScript), nameof(RenameMemberAttribute))) { var val = model.GetConstantValue(attr.ArgumentList.Arguments[0].Expression); return (string)val.Value; } } } var v = syntax.Declaration.Variables[0];//Note:Field declare always declare 1 var return v.Identifier.ValueText.LowerCase1stChar(); }
public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax field) { if (this._backingField != null) { // Retrieve the symbol for the field if (field.Declaration.Variables.Count == 1) { var variable = field.Declaration.Variables.First(); if (object.Equals(_semanticModel.GetDeclaredSymbol(variable), this._backingField)) { // We've found the backing field of the property. We don't need it anymore, so return null (means original is "replaced" by nothing) return null; } } } return base.VisitFieldDeclaration(field); }
private async Task<Document> Initialize(Document document, FieldDeclarationSyntax localDeclaration, CancellationToken cancellationToken) { var tree = await document.GetSyntaxTreeAsync(cancellationToken); var root = tree.GetRoot(cancellationToken); var constructors = root.DescendantNodes().OfType<ConstructorDeclarationSyntax>().ToList(); var csor = constructors.FirstOrDefault(); SyntaxNode visitingRoot = root; if (csor == null) { var oldClass = localDeclaration.FirstAncestorOrSelf<ClassDeclarationSyntax>(); var className = oldClass.Identifier.ToString(); var paramList = RoslynExtensions.GenerateParameters(new[] { localDeclaration.Declaration.Type }); var newCtor = SyntaxFactory.ConstructorDeclaration( attributeLists: SyntaxFactory.List(new AttributeListSyntax[] { }), modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), identifier: oldClass.Identifier, parameterList: paramList, initializer: null, body: SyntaxFactory.Block(new[] { RoslynExtensions.GenerateCtorStatement(RoslynExtensions.GetFieldName(localDeclaration), RoslynExtensions.GetFieldVariableName(localDeclaration.Declaration.Type)) }), semicolonToken: default(SyntaxToken) ); csor = newCtor; visitingRoot = root.InsertNodesAfter(localDeclaration, new[] { newCtor }); } var cr = new ConstructorRewriter(csor, localDeclaration); var newRoot = cr.Visit(visitingRoot).WithAdditionalAnnotations(Formatter.Annotation); //var workspace = MSBuildWorkspace.Create(); //var formatted = Formatter.Format(newRoot, workspace); return document.WithSyntaxRoot(newRoot); }
private static SyntaxNode MoveField(FieldDeclarationSyntax fieldDeclaration, TypeDeclarationSyntax typeDeclarationNode, SyntaxNode syntaxRoot) { var fieldToMove = new MemberOrderHelper(fieldDeclaration); foreach (var member in typeDeclarationNode.Members) { if (!member.IsKind(SyntaxKind.FieldDeclaration)) { continue; } var orderHelper = new MemberOrderHelper(member); if (orderHelper.ModifierPriority < fieldToMove.ModifierPriority) { syntaxRoot = MoveField(syntaxRoot, fieldToMove.Member, member); break; } } return syntaxRoot; }
private async Task<Solution> UnderscoreAsync(Document document, FieldDeclarationSyntax fieldDeclaration, string fieldName, CancellationToken cancellationToken) { var fieldVariable = fieldDeclaration.Declaration.Variables.First(v => v.Identifier.Text == fieldName); // Get the symbol representing the field to be renamed. var semanticModel = await document.GetSemanticModelAsync(cancellationToken); var fieldSymbol = semanticModel.GetDeclaredSymbol(fieldVariable, cancellationToken); // Compute new underscored name. var oldName = fieldVariable.Identifier.Text; var newName = "_" + GetCamelCase(oldName); // Produce a new solution that has all references to that field renamed, including the declaration. var originalSolution = document.Project.Solution; var optionSet = originalSolution.Workspace.Options; var newSolution = await Renamer.RenameSymbolAsync(document.Project.Solution, fieldSymbol, newName, optionSet, cancellationToken).ConfigureAwait(false); // Return the new solution with the now-underscored field name. return newSolution; }
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { var newName = "_" + this._relatedParam.Identifier.Text; var newField = SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration( this._relatedParam.Type, SyntaxFactory.SingletonSeparatedList<VariableDeclaratorSyntax>( SyntaxFactory.VariableDeclarator(newName)))) .WithModifiers(SyntaxFactory.TokenList().Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))); this.GeneratedField = newField; var insertIdx = 0; if (node.Members.Any(p => p is FieldDeclarationSyntax)) { insertIdx = node.Members.LastIndexOf(p => p is FieldDeclarationSyntax) + 1; } node = node.WithMembers(node.Members.Insert(insertIdx, newField)); return base.VisitClassDeclaration(node); }
private async Task<Solution> InjectViaConstructor(Document document, FieldDeclarationSyntax fieldDecl, CancellationToken cancellationToken) { var rootNode = await document.GetSyntaxRootAsync(); var constrLocatorVisitor = new ConstructorLocatorVisitor(); var targetConstructor = constrLocatorVisitor.GetTargetConstructor(rootNode); if(targetConstructor == null) { // Need to add new constructor var newConstructorWriter = new AddNewConstructorRewriter(); rootNode = newConstructorWriter.Visit(rootNode); } var rewriter = new AlterConstructorRewriter(fieldDecl, targetConstructor); rootNode = rewriter.Visit(rootNode); rootNode = Formatter.Format(rootNode, document.Project.Solution.Workspace); // Produce a new solution that has all references to that type renamed, including the declaration. return document.WithSyntaxRoot(rootNode).Project.Solution; }
public MixinReference Create(FieldDeclarationSyntax mixinFieldDeclaration) { var fieldSyntaxReader = new FieldSyntaxReader(_semantic); fieldSyntaxReader.Visit(mixinFieldDeclaration); return fieldSyntaxReader.MixinReference; }
/// <summary> /// Add documentation for the property. /// </summary> /// <param name="context">the code fix context.</param> /// <param name="root">the root syntax node.</param> /// <param name="fieldDeclaration">the property declaration containing invalid documentation.</param> /// <param name="documentComment">the existing comment.</param> /// <returns>the correct code.</returns> private Task<Document> AddDocumentationAsync( CodeFixContext context, SyntaxNode root, FieldDeclarationSyntax fieldDeclaration, DocumentationCommentTriviaSyntax documentComment) { var @class = fieldDeclaration.Parent as ClassDeclarationSyntax; var first = @class?.DescendantNodes().FirstOrDefault() == fieldDeclaration; var summary = this._commentNodeFactory.CreateCommentSummaryText(fieldDeclaration); var comment = this._commentNodeFactory .CreateDocumentComment(summary) .WithAdditionalAnnotations(Formatter.Annotation); var trivia = SyntaxFactory.Trivia(comment); var pd = first ? fieldDeclaration.WithLeadingTrivia(trivia) : fieldDeclaration.WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, trivia); var result = documentComment != null ? root.ReplaceNode(documentComment, comment.AdjustDocumentationCommentNewLineTrivia()) : root.ReplaceNode(fieldDeclaration, pd); var newDocument = context.Document.WithSyntaxRoot(result); return Task.FromResult(newDocument); }
private static bool CanBeMadeReadonly(FieldDeclarationSyntax fieldDeclaration) { return !fieldDeclaration.Modifiers.Any() || !fieldDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword) || m.IsKind(SyntaxKind.ProtectedKeyword) || m.IsKind(SyntaxKind.InternalKeyword) || m.IsKind(SyntaxKind.ReadOnlyKeyword) || m.IsKind(SyntaxKind.ConstKeyword)); }
public static bool HasModifier(this FieldDeclarationSyntax @this, SyntaxKind kind) { return(@this.Modifiers.Any(m => m.Kind() == kind)); }
public static bool IsReadOnly(this FieldDeclarationSyntax @this) { return(@this.HasModifier(SyntaxKind.ReadOnlyKeyword)); }