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