/// <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))
{
return node;
}
var declarators = new List<VariableDeclaratorSyntax>(node.Declarators.Count);
foreach (var d in node.Declarators)
{
var list = new List<ModifiedIdentifierSyntax>(d.Names.Count);
foreach (var v in d.Names)
{
var local = v;
if (!IsGoodPrivateFieldName(v.Identifier.ValueText, isInstance))
{
local = local.WithAdditionalAnnotations(s_markerAnnotationArray);
_count++;
}
list.Add(local);
}
declarators.Add(d.WithNames(SyntaxFactory.SeparatedList(list)));
}
return node.WithDeclarators(SyntaxFactory.SeparatedList(declarators));
}
public FieldMover(SemanticModel semanticModel, Symbol symbol, FieldDeclarationSyntax fds, PropertyDeclarationSyntax prop, ClassDeclarationSyntax parent)
{
this.semanticModel = semanticModel;
this.parent = parent;
this.fieldSymbol = symbol;
this.fds = fds;
this.prop = prop;
}
public LockInfo(
FieldDeclarationSyntax declaration,
FieldSymbol symbol,
AttributeData associatedAttribute,
SemanticModel semanticModel)
: base(declaration, symbol, associatedAttribute, semanticModel)
{
}
internal FieldMemberBuilder(NamedTypeSymbol owner, Binder enclosing, FieldDeclarationSyntax declaration, TypeSymbol type, VariableDeclaratorSyntax declarator)
: base(enclosing.Location(declarator) as SourceLocation, owner, enclosing)
{
this.owner = owner;
this.declaration = declaration;
this.declarator = declarator;
this.Type = type;
}
public GuardedFieldInfo(
FieldDeclarationSyntax declaration,
FieldSymbol symbol,
AttributeData associatedAttribute,
SemanticModel semanticModel)
: base(declaration, symbol, associatedAttribute, semanticModel)
{
_declaredLockHierarchy = LockHierarchy.FromStringList(Attribute.ConstructorArguments.SelectMany(arg => arg.Values.Select(argVal => argVal.Value.ToString())).ToList());
}
public CodeAction(ICodeActionEditFactory editFactory, IDocument document, FieldDeclarationSyntax member, ClassDeclarationSyntax parent)
{
this.editFactory = editFactory;
this.document = document;
this.field = member;
this.parentClass = parent;
this.Description = "Move member to parent class";
this.Icon = null;
}
public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax field)
{
// Retrieve the symbol for the field
if (field.Declaration.Variables.Count == 1)
{
if (semanticModel.GetDeclaredSymbol(field) == backingField)
{
return null;
}
}
return field;
}
protected override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax field)
{
// Retrieve the symbol for the field
if (field.Declaration.Variables.Count == 1)
{
if (semanticModel.GetDeclaredSymbol(field) == fieldSymbol)
{
//hide field from child class
return null;
}
}
return field;
}
private bool NeedsRewrite(FieldDeclarationSyntax fieldSyntax, out bool isInstance)
{
if (!IsPrivateField(fieldSyntax, out isInstance))
{
return false;
}
foreach (var d in fieldSyntax.Declarators)
{
foreach (var v in d.Names)
{
if (!IsGoodPrivateFieldName(v.Identifier.ValueText, isInstance))
{
return true;
}
}
}
return false;
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var syntaxRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken)
.ConfigureAwait(false);
var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken)
.ConfigureAwait(false);
foreach (var diagnostic in context.Diagnostics)
{
if (syntaxRoot.TryFindNodeOrAncestor(diagnostic, out ObjectCreationExpressionSyntax? objectCreation) &&
semanticModel.TryGetType(objectCreation, context.CancellationToken, out var type) &&
type.TrySingleDeclaration(context.CancellationToken, out ClassDeclarationSyntax? declaration))
{
if (diagnostic.Id == Descriptors.GURA08aShouldBeInternal.Id)
{
context.RegisterCodeFix(
CodeAction.Create(
"Make internal.",
cancellationToken => Task.FromResult(
context.Document.Project.Solution
.GetDocument(declaration.SyntaxTree)
.WithSyntaxRoot(
declaration.SyntaxTree.GetRoot(cancellationToken).ReplaceNode(
declaration,
Make(declaration, SyntaxFactory.Token(SyntaxKind.InternalKeyword))))),
nameof(AccessibilityFix)),
diagnostic);
}
else if (diagnostic.Id == Descriptors.GURA08bShouldBePublic.Id)
{
context.RegisterCodeFix(
CodeAction.Create(
"Make public.",
cancellationToken => Task.FromResult(
context.Document.Project.Solution
.GetDocument(declaration.SyntaxTree)
.WithSyntaxRoot(
declaration.SyntaxTree.GetRoot(cancellationToken).ReplaceNode(
declaration,
Make(declaration, SyntaxFactory.Token(SyntaxKind.PublicKeyword))))),
nameof(AccessibilityFix)),
diagnostic);
}
MemberDeclarationSyntax Make(MemberDeclarationSyntax before, SyntaxToken token)
{
return(before switch
{
FieldDeclarationSyntax field => field.WithModifiers(Public(field.Modifiers)),
PropertyDeclarationSyntax property => property.WithModifiers(Public(property.Modifiers)),
ClassDeclarationSyntax @class => @class.WithModifiers(Public(@class.Modifiers)),
_ => before,
});
SyntaxTokenList Public(SyntaxTokenList modifiers)
{
if (modifiers.TryFirst(out var first))
{
switch (first.Kind())
{
case SyntaxKind.InternalKeyword:
case SyntaxKind.PublicKeyword:
return(modifiers.Replace(
first,
token.WithTriviaFrom(first)));
default:
return(modifiers.Insert(0, token));
}
}
return(SyntaxTokenList.Create(token));
}
}
}
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
//Visit(node.Declaration);
}
public static bool IsVisible(FieldDeclarationSyntax field)
{
return(IsVisible(field.Modifiers));
}
PropertyDeclarationSyntax ConvertProperty(PropertyDeclarationSyntax propertyDeclaration, FieldDeclarationSyntax relatedField)
{
var leadingList = new SyntaxTriviaList();
if (relatedField.Declaration.Variables.Count == 1)
{
leadingList = leadingList.AddRange(relatedField.GetLeadingTrivia());
}
var propertyDeclaration_GetLeadingTrivia = propertyDeclaration.GetLeadingTrivia();
if (leadingList.Any() && propertyDeclaration_GetLeadingTrivia.First().IsKind(SyntaxKind.EndOfLineTrivia) == false)
{
var endOfLine = relatedField.GetLeadingTrivia().FirstOrDefault(x => x.IsKind(SyntaxKind.EndOfLineTrivia));
if (endOfLine != null)
{
leadingList = leadingList.Add(endOfLine);
}
}
leadingList = leadingList.AddRange(propertyDeclaration.GetLeadingTrivia());
var getNode = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(x => x.Keyword.IsKind(SyntaxKind.GetKeyword));
var setNode = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(x => x.Keyword.IsKind(SyntaxKind.SetKeyword));
propertyDeclaration =
propertyDeclaration
.WithAccessorList
(
propertyDeclaration.AccessorList.WithAccessors(
new SyntaxList <AccessorDeclarationSyntax>()
.Add(
getNode
.WithBody(null)
.WithTrailingTrivia()
.WithSemicolonToken(
SyntaxFactory.ParseToken(";")
.WithTrailingTrivia(SyntaxFactory.Space)
)
.WithLeadingTrivia(SyntaxFactory.Space)
)
.Add(
setNode
.WithBody(null)
.WithTrailingTrivia()
.WithSemicolonToken(
SyntaxFactory.ParseToken(";")
.WithTrailingTrivia(SyntaxFactory.Space)
)
.WithLeadingTrivia(SyntaxFactory.Space)
)
)
.WithOpenBraceToken(propertyDeclaration.AccessorList.OpenBraceToken.WithLeadingTrivia().WithTrailingTrivia())
.WithCloseBraceToken(propertyDeclaration.AccessorList.CloseBraceToken.WithLeadingTrivia())
)
.WithIdentifier(propertyDeclaration.Identifier.WithTrailingTrivia(SyntaxFactory.Space))
.WithLeadingTrivia(leadingList);
return(propertyDeclaration);
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
VariableDeclaratorSyntax variableDeclaration = node.DescendantNodes().OfType<VariableDeclaratorSyntax>().First();
FieldSymbol field = (FieldSymbol) _semanticModel.GetDeclaredSymbol(variableDeclaration);
if (field != null)
{
var attributes = field.GetAttributes();
foreach (AttributeData attribute in attributes)
{
if (attribute.IsInstanceOfAttributeType<GuardedByAttribute>())
{
GuardedFieldInfo guardedField = new GuardedFieldInfo(node, field, attribute, _semanticModel);
_guardedFields.Add(guardedField);
}
else if (attribute.IsInstanceOfAttributeType<LockAttribute>())
{
LockInfo lockField = new LockInfo(node, field, attribute, _semanticModel);
_locks.Add(lockField);
}
else
{
//do nothing
}
}
}
base.VisitFieldDeclaration(node);
}
private static void HandleFieldDeclaration(SyntaxNodeAnalysisContext context)
{
FieldDeclarationSyntax syntax = (FieldDeclarationSyntax)context.Node;
if (NamedTypeHelpers.IsContainedInNativeMethodsClass(syntax))
{
return;
}
if (syntax.Modifiers.Any(SyntaxKind.ConstKeyword))
{
// this diagnostic does not apply to constant fields
return;
}
if (syntax.Modifiers.Any(SyntaxKind.PublicKeyword) ||
syntax.Modifiers.Any(SyntaxKind.InternalKeyword))
{
// this diagnostic does not apply to public or internal read only fields
return;
}
if (syntax.Modifiers.Any(SyntaxKind.ReadOnlyKeyword) &&
syntax.Modifiers.Any(SyntaxKind.ProtectedKeyword))
{
// this diagnostic does not apply to non-private read only fields
return;
}
if (syntax.Modifiers.Any(SyntaxKind.ReadOnlyKeyword) &&
syntax.Modifiers.Any(SyntaxKind.StaticKeyword))
{
// this diagnostic does not apply to static read only fields
return;
}
var variables = syntax.Declaration?.Variables;
if (variables == null)
{
return;
}
foreach (VariableDeclaratorSyntax variableDeclarator in variables.Value)
{
if (variableDeclarator == null)
{
continue;
}
var identifier = variableDeclarator.Identifier;
if (identifier.IsMissing)
{
continue;
}
string name = identifier.ValueText;
if (string.IsNullOrEmpty(name))
{
continue;
}
var index = 0;
while ((index < name.Length) && name[index] == '_')
{
index++;
}
if (index == name.Length)
{
// ignore fields with all underscores
continue;
}
if (char.IsLower(name, index))
{
continue;
}
// Field names must begin with lower-case letter
context.ReportDiagnostic(Diagnostic.Create(Descriptor, identifier.GetLocation(), name));
}
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
base.VisitFieldDeclaration(node);
}
public void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
VisitBaseFieldDeclaration(node);
}
/// <summary>
/// Creates an entry method, that is used to execute query for normal modules
/// or that can be used as a base for a query for query modules.
/// </summary>
protected void GenerateMethod(
Module module, IEnumerable<Parameter> methodParameters, string resultClassName,
FieldDeclarationSyntax propsField, string fileName, bool nullableParameters, SortType? sortType)
{
var propertiesField = CreatePropertiesField(module, resultClassName, propsField, sortType);
ExpressionSyntax queryParameters = SyntaxEx.Invocation(
SyntaxEx.MemberAccess("QueryParameters", SyntaxEx.GenericName("Create", resultClassName)));
var queryParametersLocal = SyntaxEx.LocalDeclaration("var", "queryParameters", queryParameters);
var documentationElements = new List<XmlElementSyntax>();
var summary = SyntaxEx.DocumentationSummary(module.Description);
documentationElements.Add(summary);
var parameters = new List<ParameterSyntax>();
IList<StatementSyntax> statements = new List<StatementSyntax>();
statements.Add(queryParametersLocal);
methodParameters = methodParameters.Where(p => !p.Deprecated)
.OrderByDescending(p => p.Required);
foreach (var methodParameter in methodParameters)
{
var nullable = nullableParameters && !methodParameter.Required;
var typeName = Wiki.TypeManager.GetTypeName(methodParameter, ClassNameBase, nullable, false);
var parameterName = GetPropertyName(methodParameter.Name);
var parameter = SyntaxEx.Parameter(typeName, parameterName, nullable ? SyntaxEx.NullLiteral() : null);
parameters.Add(parameter);
ExpressionSyntax valueExpression = (NamedNode)parameter;
if (nullable && typeName.EndsWith("?"))
valueExpression = SyntaxEx.MemberAccess(valueExpression, "Value");
var queryParametersAssignment = SyntaxEx.Assignment(
queryParametersLocal, SyntaxEx.Invocation(
SyntaxEx.MemberAccess(queryParametersLocal, "AddSingleValue"),
SyntaxEx.Literal(methodParameter.Name),
SyntaxEx.Invocation(SyntaxEx.MemberAccess(valueExpression, "ToQueryString"))));
if (nullable)
{
var assignmentWithCheck = SyntaxEx.If(
SyntaxEx.NotEquals((NamedNode)parameter, SyntaxEx.NullLiteral()), queryParametersAssignment);
statements.Add(assignmentWithCheck);
}
else
statements.Add(queryParametersAssignment);
var parameterDocumentation = SyntaxEx.DocumentationParameter(
parameterName, new System.Xml.Linq.XText(methodParameter.Description).ToString());
documentationElements.Add(parameterDocumentation);
}
statements = GenerateMethodBody(
SyntaxEx.ObjectCreation(
SyntaxEx.GenericName("QueryProcessor", resultClassName),
Syntax.IdentifierName("m_wiki"),
(NamedNode)propertiesField), (NamedNode)queryParametersLocal, statements);
var modifiers = new List<SyntaxKind> { SyntaxKind.PublicKeyword };
if (statements == null)
modifiers.Add(SyntaxKind.AbstractKeyword);
var method = SyntaxEx.MethodDeclaration(
modifiers, GenerateMethodResultType(), ClassNameBase, parameters, statements)
.WithLeadingTrivia(Syntax.Trivia(SyntaxEx.DocumentationComment(documentationElements)));
AddMembersToClass(fileName, propertiesField, method);
}
public static FieldDeclarationSyntax FieldDeclaration(VariableDeclarationSyntax declaration = null)
{
var result = new FieldDeclarationSyntax();
result.Declaration = declaration;
return result;
}
public static FieldDeclarationSyntax FieldDeclaration(IEnumerable<AttributeListSyntax> attributeLists = null, Modifiers modifiers = default(Modifiers), VariableDeclarationSyntax declaration = null)
{
var result = new FieldDeclarationSyntax();
if (attributeLists != null)
result.AttributeLists.AddRange(attributeLists);
result.Modifiers = modifiers;
result.Declaration = declaration;
return result;
}
private bool CanBecameReadOnlyField(FieldDeclarationSyntax field)
{
var noPrivate = field.Modifiers.Any(p => p.IsKind(SyntaxKind.PublicKeyword) || p.IsKind(SyntaxKind.ProtectedKeyword) || p.IsKind(SyntaxKind.InternalKeyword));
return(noPrivate ? !field.Modifiers.Any(p => p.IsKind(SyntaxKind.ConstKeyword) || p.IsKind(SyntaxKind.ReadOnlyKeyword)) : false);
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
AsChild(node, node.Declaration.Variables.First().Identifier.Text, node.Declaration.Variables.First().Identifier.GetLocation());
}
internal static void AddField(this DocumentEditor editor, TypeDeclarationSyntax containingType, FieldDeclarationSyntax field)
{
FieldDeclarationSyntax existing = null;
foreach (var member in containingType.Members)
{
if (member is FieldDeclarationSyntax fieldDeclaration)
{
if (IsInsertBefore(fieldDeclaration))
{
editor.InsertBefore(fieldDeclaration, field);
return;
}
existing = fieldDeclaration;
continue;
}
editor.InsertBefore(member, field);
return;
}
if (existing != null)
{
editor.InsertAfter(existing, field);
}
else
{
editor.AddMember(containingType, field);
}
}
private static IEnumerable <MemberDeclarationSyntax> CreateMembers(IEnumerable <AnalyzerMetadata> analyzers)
{
foreach (AnalyzerMetadata analyzer in analyzers)
{
FieldDeclarationSyntax fieldDeclaration = FieldDeclaration(
Modifiers.Public_Static_ReadOnly(),
IdentifierName("DiagnosticDescriptor"),
analyzer.Identifier,
ObjectCreationExpression(
IdentifierName("DiagnosticDescriptor"),
ArgumentList(
Argument(
NameColon("id"),
SimpleMemberAccessExpression(IdentifierName("DiagnosticIdentifiers"), IdentifierName(analyzer.Identifier))),
Argument(
NameColon("title"),
StringLiteralExpression(analyzer.Title)),
Argument(
NameColon("messageFormat"),
StringLiteralExpression(analyzer.MessageFormat)),
Argument(
NameColon("category"),
SimpleMemberAccessExpression(IdentifierName("DiagnosticCategories"), IdentifierName(analyzer.Category))),
Argument(
NameColon("defaultSeverity"),
SimpleMemberAccessExpression(IdentifierName("DiagnosticSeverity"), IdentifierName(analyzer.DefaultSeverity))),
Argument(
NameColon("isEnabledByDefault"),
BooleanLiteralExpression(analyzer.IsEnabledByDefault)),
Argument(
NameColon("description"),
NullLiteralExpression()),
Argument(
NameColon("helpLinkUri"),
ParseExpression($"$\"{{HelpLinkUriRoot}}{{DiagnosticIdentifiers.{analyzer.Identifier}}}\"")),
Argument(
NameColon("customTags"),
(analyzer.SupportsFadeOut)
? SimpleMemberAccessExpression(IdentifierName("WellKnownDiagnosticTags"), IdentifierName("Unnecessary"))
: ParseExpression("Array.Empty<string>()"))
))).AddObsoleteAttributeIf(analyzer.IsObsolete, error: true);
if (!analyzer.IsObsolete)
{
var settings = new DocumentationCommentGeneratorSettings(
summary: new string[] { analyzer.Id },
indentation: " ",
singleLineSummary: true);
fieldDeclaration = fieldDeclaration.WithNewSingleLineDocumentationComment(settings);
}
yield return(fieldDeclaration);
if (analyzer.SupportsFadeOutAnalyzer)
{
yield return(FieldDeclaration(
Modifiers.Public_Static_ReadOnly(),
IdentifierName("DiagnosticDescriptor"),
analyzer.Identifier + "FadeOut",
SimpleMemberInvocationExpression(
IdentifierName(analyzer.Identifier),
IdentifierName("CreateFadeOut"))).AddObsoleteAttributeIf(analyzer.IsObsolete, error: true));
}
}
}
public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
{
node = (FieldDeclarationSyntax)base.VisitFieldDeclaration(node);
Classes.Add(node);
return(node);
}
bool CheckVisibility(FieldDeclarationSyntax baseFieldFieldDeclaration, AccessorDeclarationSyntax getNode, AccessorDeclarationSyntax setNode, PropertyDeclarationSyntax propertyDeclaration)
{
if (baseFieldFieldDeclaration.IsPrivate())
{
return(true);
}
else
{
if (baseFieldFieldDeclaration.IsPublic())
{
if (propertyDeclaration.IsPublic() == false)
{
return(false);
}
if (getNode.Modifiers.Any())
{
return(false);
}
if (setNode.Modifiers.Any())
{
return(false);
}
}
else if (baseFieldFieldDeclaration.IsProtected())
{
if (propertyDeclaration.IsPrivate() == false)
{
return(false);
}
if (propertyDeclaration.IsProtected())
{
if (getNode.Modifiers.Any())
{
return(false);
}
if (setNode.Modifiers.Any())
{
return(false);
}
}
else if (propertyDeclaration.IsPublic())
{
if (baseFieldFieldDeclaration.IsInternal() == false)
{
if (getNode.Modifiers.Any(x => x.IsKind(SyntaxKind.PrivateKeyword) || x.IsKind(SyntaxKind.InternalKeyword)))
{
return(false);
}
if (setNode.Modifiers.Any(x => x.IsKind(SyntaxKind.PrivateKeyword) || x.IsKind(SyntaxKind.InternalKeyword)))
{
return(false);
}
}
else
{
if (getNode.Modifiers.Any(x => x.IsKind(SyntaxKind.PrivateKeyword)))
{
return(false);
}
if (setNode.Modifiers.Any(x => x.IsKind(SyntaxKind.PrivateKeyword)))
{
return(false);
}
}
}
}
else if (baseFieldFieldDeclaration.IsInternal())
{
if (propertyDeclaration.IsPrivate() == false)
{
return(false);
}
if (propertyDeclaration.IsInternal())
{
if (getNode.Modifiers.Any())
{
return(false);
}
if (setNode.Modifiers.Any())
{
return(false);
}
}
else if (propertyDeclaration.IsPublic())
{
if (getNode.Modifiers.Any(x => x.IsKind(SyntaxKind.PrivateKeyword) || x.IsKind(SyntaxKind.ProtectedKeyword)))
{
return(false);
}
if (setNode.Modifiers.Any(x => x.IsKind(SyntaxKind.PrivateKeyword) || x.IsKind(SyntaxKind.ProtectedKeyword)))
{
return(false);
}
}
}
}
return(true);
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
base.VisitFieldDeclaration(node);
FilterType(node.Declaration.Type);
}
private List <System.Attribute> GetFieldAttributes(FieldDeclarationSyntax node)
{
List <System.Attribute> attributes = new List <System.Attribute>();
if (node.AttributeLists != null)
{
foreach (AttributeListSyntax attributeList in node.AttributeLists)
{
UpdateSyntaxNode(attributeList);
foreach (AttributeSyntax attribute in attributeList.Attributes)
{
using (ExpressionCaptureScope attributeTypeCapture = new ExpressionCaptureScope(visitorContext, null))
{
attributeTypeCapture.isAttributeCaptureScope = true;
Visit(attribute.Name);
System.Type captureType = attributeTypeCapture.captureType;
if (captureType == typeof(UdonSyncedAttribute))
{
UdonSyncMode syncMode = UdonSyncMode.NotSynced;
if (attribute.ArgumentList == null ||
attribute.ArgumentList.Arguments == null ||
attribute.ArgumentList.Arguments.Count == 0)
{
syncMode = UdonSyncMode.None;
}
else
{
using (ExpressionCaptureScope attributeCaptureScope = new ExpressionCaptureScope(visitorContext, null))
{
Visit(attribute.ArgumentList.Arguments[0].Expression);
if (!attributeCaptureScope.IsEnum())
{
throw new System.Exception("Invalid attribute argument provided for sync");
}
syncMode = (UdonSyncMode)attributeCaptureScope.GetEnumValue();
}
}
attributes.Add(new UdonSyncedAttribute(syncMode));
}
else if (captureType != null)
{
try
{
object attributeObject = null;
if (attribute.ArgumentList == null ||
attribute.ArgumentList.Arguments == null ||
attribute.ArgumentList.Arguments.Count == 0)
{
attributeObject = System.Activator.CreateInstance(captureType);
}
else
{
// todo: requires constant folding to support decently
object[] attributeArgs = new object[attribute.ArgumentList.Arguments.Count];
for (int i = 0; i < attributeArgs.Length; ++i)
{
AttributeArgumentSyntax attributeArg = attribute.ArgumentList.Arguments[i];
using (ExpressionCaptureScope attributeCapture = new ExpressionCaptureScope(visitorContext, null))
{
Visit(attributeArg);
SymbolDefinition attrSymbol = attributeCapture.ExecuteGet();
if (!attrSymbol.declarationType.HasFlag(SymbolDeclTypeFlags.Constant))
{
throw new System.ArgumentException("Attributes do not support non-constant expressions");
}
attributeArgs[i] = attrSymbol.symbolDefaultValue;
}
}
attributeObject = System.Activator.CreateInstance(captureType, attributeArgs);
}
if (attributeObject != null)
{
attributes.Add((System.Attribute)attributeObject);
}
}
catch (System.Reflection.TargetInvocationException constructionException)
{
throw constructionException.InnerException;
}
}
}
}
}
}
return(attributes);
}
/// <summary>
/// Obtient la location d'un nom de field.
/// </summary>
/// <param name="node">Node de field.</param>
/// <returns>Location du field.</returns>
public static Location GetFieldNameLocation(this FieldDeclarationSyntax node)
{
/* Suppose qu'il n'y a qu'une seule variable. */
return(node.Declaration.Variables.First().Identifier.GetLocation());
}
private bool CanEncapsulate(FieldDeclarationSyntax field) => field.Parent is TypeDeclarationSyntax;
/// <summary>
/// Creates methods to create <see cref="ListSourceBase{TPage}"/> page sources
/// for the <c>Wiki</c> class.
/// </summary>
private static IEnumerable<MethodDeclarationSyntax> CreatePageSourceMethods(FieldDeclarationSyntax wikiField)
{
var pageSources =
new[]
{
new { type = "string", name = "titles", sourceType = typeof(TitlesSource<>) },
new { type = "long", name = "pageIds", sourceType = typeof(PageIdsSource<>) },
new { type = "long", name = "revIds", sourceType = typeof(RevIdsSource<>) }
};
foreach (var pageSource in pageSources)
{
string sourceTypeName = pageSource.sourceType.Name;
sourceTypeName = sourceTypeName.Substring(0, sourceTypeName.IndexOf('`'));
var parameterVersions =
new[]
{
SyntaxEx.Parameter(SyntaxEx.GenericName("IEnumerable", pageSource.type), pageSource.name),
SyntaxEx.Parameter(
pageSource.type + "[]", pageSource.name, modifiers: new[] { SyntaxKind.ParamsKeyword })
};
foreach (var parameter in parameterVersions)
{
var returnStatement = SyntaxEx.Return(
SyntaxEx.ObjectCreation(
SyntaxEx.GenericName(sourceTypeName, Names.Page),
(NamedNode)wikiField, (NamedNode)parameter));
yield return SyntaxEx.MethodDeclaration(
new[] { SyntaxKind.PublicKeyword }, SyntaxEx.GenericName("PagesSource", Names.Page),
"Create" + sourceTypeName, new[] { parameter }, returnStatement);
}
}
}
/// <summary>
/// Creates a new <see cref="Syntax.ModifierListInfo"/> from the specified field declaration.
/// </summary>
/// <param name="fieldDeclaration"></param>
/// <returns></returns>
public static ModifierListInfo ModifierListInfo(FieldDeclarationSyntax fieldDeclaration)
{
return(Syntax.ModifierListInfo.Create(fieldDeclaration));
}
public virtual void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
DefaultVisit(node);
}
static async Task <Solution> MoveMessagePrefixToCallSitesAsync(Document document,
FieldDeclarationSyntax fieldDecl, CancellationToken cancellationToken)
{
// TODO: simplify this using SyntaxEditor?
var messageDocId = document.Id;
// we'll need to track the field across renames
var fieldDeclAnnotation = new SyntaxAnnotation();
var root = await document.GetSyntaxRootAsync(cancellationToken);
document = document.WithSyntaxRoot(
root.ReplaceNode(
fieldDecl,
fieldDecl.WithAdditionalAnnotations(fieldDeclAnnotation)));
var solution = document.Project.Solution;
FieldDeclarationSyntax FindFieldDecl(SyntaxNode node) =>
node.DescendantNodes()
.OfType <FieldDeclarationSyntax>()
.Single(n => n.HasAnnotation(fieldDeclAnnotation));
ExpressionSyntax FindFormatExpr(SyntaxNode node) =>
FindFieldDecl(node)
.DescendantNodes()
.OfType <AttributeSyntax>()
.First(a => a.Name.ToString() == "Message" || a.Name.ToString() == "MessageAttribute")
.DescendantNodes()
.OfType <AttributeArgumentSyntax>()
.First()
.Expression;
// get format string and split it into prefix + rest
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
root = await document.GetSyntaxRootAsync(cancellationToken);
var formatStr = (string)semanticModel.GetConstantValue(FindFormatExpr(root), cancellationToken).Value;
var match = MessageConstantAnalyzer.PrefixedMessageFormatRegex.Match(formatStr);
var prefix = match.Groups["prefix"].Value;
var rest = match.Groups["rest"].Value;
var newFormatStr = "{0}" + IncrementFormatTokens(rest);
// replace format string
var newFormatExpr = SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(newFormatStr));
var pendingReplacements = ImmutableList.Create(
new PendingReplacement(document, FindFormatExpr(root), newFormatExpr));
async Task ApplyPendingReplacementsAsync()
{
// ReSharper disable AccessToModifiedClosure
var replacementsByDocument = pendingReplacements.GroupBy(pr => pr.Document);
pendingReplacements = pendingReplacements.Clear();
foreach (var group in replacementsByDocument)
{
var syntaxMapping = group.ToDictionary(pr => pr.Old, pr => pr.New);
var syntaxRoot = await group.Key.GetSyntaxRootAsync(cancellationToken);
var newSyntaxRoot = syntaxRoot.ReplaceNodes(syntaxMapping.Keys, (node, _) => syntaxMapping[node]);
solution = solution.WithDocumentSyntaxRoot(group.Key.Id, newSyntaxRoot);
}
// ReSharper restore AccessToModifiedClosure
}
var fieldSymbol = semanticModel.GetDeclaredSymbol(
FindFieldDecl(await document.GetSyntaxRootAsync(cancellationToken)).Declaration.Variables[0],
cancellationToken);
if (fieldSymbol != null)
{
// rename constant if the name matches the old message format
if (fieldSymbol.Name == ErrorExceptionUsageCodeFixProvider.GetConstantNameFromMessageFormat(formatStr))
{
await ApplyPendingReplacementsAsync();
var newCompilation = await solution.GetDocument(messageDocId).Project.GetCompilationAsync(cancellationToken);
fieldSymbol = SymbolFinder.FindSimilarSymbols(fieldSymbol, newCompilation, cancellationToken).First();
var newName = ErrorExceptionUsageCodeFixProvider.GetConstantNameFromMessageFormat(newFormatStr);
solution = await Renamer.RenameSymbolAsync(solution, fieldSymbol, newName,
solution.Workspace.Options, cancellationToken);
var newDocument = solution.GetDocument(messageDocId);
var newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken);
var newFieldDecl = FindFieldDecl(newRoot);
var newSemanticModel = await newDocument.GetSemanticModelAsync(cancellationToken);
fieldSymbol = newSemanticModel.GetDeclaredSymbol(newFieldDecl.Declaration.Variables[0]);
}
// update call sites
var prefixSyntax = SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(prefix));
var references = await SymbolFinder.FindReferencesAsync(fieldSymbol, solution, cancellationToken);
var rs = references.SingleOrDefault();
if (rs != null)
{
foreach (var location in rs.Locations.Where(l => !l.IsCandidateLocation && !l.IsImplicit))
{
var replacement = await ReplacementCallSiteWithPrefixInsertedAsync(location, prefixSyntax, cancellationToken);
if (replacement != null)
{
pendingReplacements = pendingReplacements.Add(replacement);
}
}
}
}
// apply pending replacements
await ApplyPendingReplacementsAsync();
return(solution);
}
/// <summary>
/// Creates class that used in the <c>select</c> clause.
/// </summary>
private ClassDeclarationSyntax GenerateSelect(IEnumerable<PropertyGroup> propertyGroups, bool first)
{
propertyGroups = propertyGroups.Where(pg => pg.Name != null).ToArray();
var propsField = CreatePropsField(propertyGroups);
m_selectProps = propsField;
AddMembersToClass(MethodClassName, propsField);
var properties = propertyGroups.SelectMany(g => g.Properties).Distinct();
return GenerateClassForProperties(m_selectClassName, properties, first ? "IFirst" : null);
}
/// <summary>
/// Obtient le nom d'un node de field.
/// </summary>
/// <param name="node">Node de field.</param>
/// <returns>Nom du field.</returns>
public static string GetFieldName(this FieldDeclarationSyntax node)
{
/* Suppose qu'il n'y a qu'une seule variable. */
return(node.Declaration.Variables.First().Identifier.ValueText);
}
private bool IsPrivateField(FieldDeclarationSyntax node, out bool isInstance)
{
var isPrivate = true;
isInstance = !_inModule;
foreach (var modifier in node.Modifiers)
{
switch (modifier.Kind())
{
case SyntaxKind.PublicKeyword:
case SyntaxKind.FriendKeyword:
case SyntaxKind.ProtectedKeyword:
isPrivate = false;
break;
case SyntaxKind.SharedKeyword:
isInstance = false;
break;
}
}
return isPrivate;
}
private bool CanEncapsulate(FieldDeclarationSyntax field)
{
return(field.Parent is TypeDeclarationSyntax);
}
public void Add(FieldDeclarationSyntax node)
{
// add field info
Add(node.Modifiers, node.Declaration);
/*
// Summary:
// Gets the attribute declaration list.
public override SyntaxList<AttributeListSyntax> AttributeLists { get; }
public override VariableDeclarationSyntax Declaration { get; }
//
// Summary:
// Gets the modifier list.
public override SyntaxTokenList Modifiers { get; }
public override SyntaxToken SemicolonToken { get; }
*/
// add to metadata for runtime type building
FlatArrayBuilder fab = new FlatArrayBuilder();
fab.Add(FlatValue.Int32(node.Modifiers.ToString().Contains("static") ? (int)ClassMemberType.StaticField : (int)ClassMemberType.Field));
TypeInfo ti = Chunk.Model.GetTypeInfo(node.Declaration.Type);
fab.Add(FlatValue.String(ti.ConvertedType.GetFullyQualifiedName()));
{
FlatArrayBuilder varList = new FlatArrayBuilder();
foreach (VariableDeclaratorSyntax vds in node.Declaration.Variables)
{
if (vds.ArgumentList != null)
{
throw new NotImplementedException("array field");
}
varList.Add(FlatValue.String(vds.Identifier.ToString()));
}
fab.Add(varList.GetFlatValue());
}
Members.Add(fab.GetFlatValue());
}
private void HandleFieldDeclarationSyntax(SyntaxNodeAnalysisContext context)
{
FieldDeclarationSyntax syntax = (FieldDeclarationSyntax)context.Node;
bool isStatic = false;
foreach (SyntaxToken token in syntax.Modifiers)
{
switch (token.Kind())
{
case SyntaxKind.StaticKeyword:
isStatic = true;
break;
case SyntaxKind.ReadOnlyKeyword:
case SyntaxKind.ConstKeyword:
// This analyzer only looks at static, non-const, non-readonly fields.
return;
case SyntaxKind.InternalKeyword:
case SyntaxKind.ProtectedKeyword:
case SyntaxKind.PublicKeyword:
// This analyzer only looks at private fields.
return;
default:
break;
}
}
if (!isStatic)
{
return;
}
if (NamedTypeHelpers.IsContainedInNativeMethodsClass(syntax))
{
return;
}
var variables = syntax.Declaration?.Variables;
if (variables == null)
{
return;
}
foreach (VariableDeclaratorSyntax variableDeclarator in variables.Value)
{
if (variableDeclarator == null)
{
continue;
}
var identifier = variableDeclarator.Identifier;
if (identifier.IsMissing)
{
continue;
}
if (identifier.ValueText.StartsWith("_"))
{
continue;
}
// Static field '{name}' must begin with an underscore
string name = identifier.ValueText;
context.ReportDiagnostic(Diagnostic.Create(Descriptor, identifier.GetLocation(), name));
}
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
AddField(node);
base.VisitFieldDeclaration(node);
}
public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
{
// the script compile treats Dims at the top level as FieldDeclarations which doesn't make sense in context, so just
// globally swap them to LocalDeclarations
return(Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.LocalDeclarationStatement(node.Modifiers, node.Declarators));
}
private static MethodDeclarationSyntax ParseMethod(string code, bool usesUnderscoreNames, FieldDeclarationSyntax field = null)
{
if (field != null &&
field.Name() != "disposed")
{
code = code.Replace("disposed", field.Name());
}
if (usesUnderscoreNames)
{
code = code.Replace("this.", string.Empty);
}
return((MethodDeclarationSyntax)SyntaxFactory.ParseCompilationUnit(code)
.Members
.Single()
.WithSimplifiedNames()
.WithLeadingTrivia(SyntaxFactory.ElasticMarker)
.WithTrailingTrivia(SyntaxFactory.ElasticMarker)
.WithAdditionalAnnotations(Formatter.Annotation));
}
internal static IFieldSymbol GetDeclaredSymbolSafe(this SemanticModel semanticModel, FieldDeclarationSyntax node, CancellationToken cancellationToken)
{
return((IFieldSymbol)semanticModel.SemanticModelFor(node)
?.GetDeclaredSymbol(node, cancellationToken));
}
/// <summary>
/// Creates the proper helper.
/// </summary>
/// <param name="node"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
/// <remarks>
/// Must return a type deriving from <see cref="FieldDeclaration"/>.
/// </remarks>
protected virtual FieldDeclaration CreateHelper(FieldDeclarationSyntax node, SemanticModel semanticModel)
{
return(new FieldDeclaration(this.Node as FieldDeclarationSyntax, this.SemanticModel));
}
private static void HandleFieldDeclarationSyntax(SyntaxNodeAnalysisContext context)
{
FieldDeclarationSyntax syntax = (FieldDeclarationSyntax)context.Node;
if (NamedTypeHelpers.IsContainedInNativeMethodsClass(syntax))
{
return;
}
var variables = syntax.Declaration?.Variables;
if (variables == null)
{
return;
}
foreach (VariableDeclaratorSyntax variableDeclarator in variables.Value)
{
if (variableDeclarator == null)
{
continue;
}
var identifier = variableDeclarator.Identifier;
if (identifier.IsMissing)
{
continue;
}
switch (identifier.ValueText.IndexOf('_'))
{
case -1:
// no _ character
continue;
case 0:
// leading underscore -> report as SA1309
continue;
case 1:
switch (identifier.ValueText[0])
{
case 'm':
case 's':
case 't':
// m_, s_, and t_ prefixes are reported as SA1308
continue;
default:
break;
}
break;
default:
break;
}
// Field '{name}' must not contain an underscore
string name = identifier.ValueText;
context.ReportDiagnostic(Diagnostic.Create(Descriptor, identifier.GetLocation(), name));
}
}
/// <inheritdoc />
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
// don't walk
}
public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
{
node = (FieldDeclarationSyntax)base.VisitFieldDeclaration(node);
return(node.AppendToTrailingTrivia(NewLine()));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, FieldDeclarationSyntax fieldDeclaration)
{
if (fieldDeclaration.IsConst())
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceConstantWithField) &&
fieldDeclaration.Span.Contains(context.Span))
{
context.RegisterRefactoring(
"Replace constant with field",
cancellationToken => ReplaceConstantWithFieldRefactoring.RefactorAsync(context.Document, fieldDeclaration, cancellationToken));
}
}
else if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceFieldWithConstant) &&
fieldDeclaration.Modifiers.Contains(SyntaxKind.ReadOnlyKeyword) &&
fieldDeclaration.IsStatic() &&
fieldDeclaration.Span.Contains(context.Span))
{
if (await ReplaceFieldWithConstantRefactoring.CanRefactorAsync(context, fieldDeclaration).ConfigureAwait(false))
{
context.RegisterRefactoring(
"Replace field with constant",
cancellationToken => ReplaceFieldWithConstantRefactoring.RefactorAsync(context.Document, fieldDeclaration, cancellationToken));
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MarkMemberAsStatic) &&
fieldDeclaration.Span.Contains(context.Span) &&
MarkMemberAsStaticRefactoring.CanRefactor(fieldDeclaration))
{
context.RegisterRefactoring(
"Mark field as static",
cancellationToken => MarkMemberAsStaticRefactoring.RefactorAsync(context.Document, fieldDeclaration, cancellationToken));
}
}
public CodeRefactoring GetRefactoring(IDocument document, TextSpan textSpan, CancellationToken cancellationToken)
{
SyntaxNode root = (SyntaxNode)document.GetSyntaxRoot(cancellationToken);
ISemanticModel model = document.GetSemanticModel(cancellationToken);
SyntaxToken token = root.FindToken(textSpan.Start, findInsideTrivia: true);
// Verify is the selected token an identifier within field declaration
if (token.Kind == SyntaxKind.IdentifierToken && token.Span.Start <= textSpan.End && textSpan.End <= token.Span.End)
{
SyntaxNode parentNode = token.Parent;
if (parentNode == null)
{
return(null);
}
FieldDeclarationSyntax fieldDeclaration = parentNode.FirstAncestorOrSelf <FieldDeclarationSyntax>();
if (fieldDeclaration == null)
{
return(null);
}
// If the FieldDeclaration has some errors, then no refactoring should take place
if (fieldDeclaration.HasDiagnostics)
{
return(null);
}
// Get the container that the field belongs to
TypeDeclarationSyntax containingType = fieldDeclaration.FirstAncestorOrSelf <TypeDeclarationSyntax>();
if (containingType == null)
{
return(null);
}
// Obtain TypeSymbol for class declaration
ITypeSymbol containingTypeSymbol = model.GetDeclaredSymbol(containingType, cancellationToken) as ITypeSymbol;
if (containingTypeSymbol == null)
{
return(null);
}
// Check is there a base class that the field can be moved to
INamedTypeSymbol baseTypeSymbol = containingTypeSymbol.BaseType;
if (baseTypeSymbol == null)
{
return(null);
}
// Check is the class defined in source, so that it can be extended
CommonLocation baseTypeLocation = baseTypeSymbol.Locations.First();
if (baseTypeLocation != null && baseTypeLocation.IsInSource)
{
int position = baseTypeLocation.SourceSpan.Start;
BaseTypeDeclarationSyntax baseTypeDeclaration = baseTypeLocation.SourceTree.GetRoot().FindToken(position).Parent.FirstAncestorOrSelf <BaseTypeDeclarationSyntax>();
if (baseTypeDeclaration == null)
{
return(null);
}
return(new CodeRefactoring(
new[] { new PullUpFieldAction(document, fieldDeclaration, containingType, baseTypeDeclaration) }
, fieldDeclaration.Span));
}
}
return(null);
}
private Variables TraverseField(FieldDeclarationSyntax fds)
{
Variables retVar = new Variables();
//Name
//Encapsulation
foreach (SyntaxToken st in fds.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
retVar.Accessibility.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
retVar.Qualifiers.Add(qual);
}
}
return retVar;
}
