public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
var newProperty = base.VisitPropertyDeclaration(node) as PropertyDeclarationSyntax;
if (_classDeclarationContext.Current.TestCaseSources.Any(x => x.ValueText == newProperty.Identifier.ValueText))
{
if (node.Type is GenericNameSyntax genericType &&
genericType.TypeArgumentList.Arguments.Count == 1 &&
genericType.TypeArgumentList.Arguments.First() is IdentifierNameSyntax closedType) // This is always IdentifierNameSyntax because it is IEnumerable<TestCaseData> type.
{
var genericSymbol = _semanticModel.GetSymbolInfo(closedType).Symbol;
if (!AttributesRecognizer.IsTestCaseData(genericSymbol))
{
return(newProperty);
}
newProperty = newProperty.WithType(genericType.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.ArrayType(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.ObjectKeyword)
), SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression())))
)
)
)
)
);
}
}
return(newProperty);
}
/// <summary>
/// Returns <see cref="ArrayTypeSyntax"/> representing the array form of <paramref name="type"/>.
/// </summary>
/// <param name="type">
/// The type.
/// </param>
/// <param name="includeNamespace">
/// A value indicating whether or not to include the namespace name.
/// </param>
/// <returns>
/// <see cref="ArrayTypeSyntax"/> representing the array form of <paramref name="type"/>.
/// </returns>
public static ArrayTypeSyntax GetArrayTypeSyntax(this Type type, bool includeNamespace = true)
{
return
(SyntaxFactory.ArrayType(SyntaxFactory.ParseTypeName(type.GetParseableName(includeNamespace: includeNamespace)))
.AddRankSpecifiers(
SyntaxFactory.ArrayRankSpecifier().AddSizes(SyntaxFactory.OmittedArraySizeExpression())));
}
public static ArrayCreationExpressionSyntax CreateArrayOf(string typeName, ExpressionSyntax[] expressions,
int ranksAmount = 1)
{
var newKeyword = SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.NewKeyword,
SyntaxTriviaList.Create(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")));
var syntaxList = new SeparatedSyntaxList <ExpressionSyntax>();
for (var i = 0; i < expressions.Length; i++)
{
syntaxList = syntaxList.Add(expressions[i]);
}
var rankSpecifiers = new SyntaxList <ArrayRankSpecifierSyntax>();
for (var i = 0; i < ranksAmount; i++)
{
rankSpecifiers = rankSpecifiers.Add(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.Token(SyntaxKind.OpenBracketToken),
new SeparatedSyntaxList <ExpressionSyntax>
{
SyntaxFactory.OmittedArraySizeExpression(
SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)
)
},
SyntaxFactory.Token(SyntaxKind.CloseBracketToken)
)
);
}
return(SyntaxFactory.ArrayCreationExpression(
newKeyword,
SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(typeName), rankSpecifiers),
SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, syntaxList)));
}
public static TypeSyntax GetTypeNameSyntax(this TypeMember type)
{
var clrBinding = type.Bindings.FirstOrDefault <System.Type>();
if (clrBinding != null)
{
if (clrBinding.IsArray)
{
var elementTypeSyntax = GetTypeNameSyntax(type.UnderlyingType);
return(SyntaxFactory.ArrayType(elementTypeSyntax)
.WithRankSpecifiers(SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression())))));
}
if (_s_keywordPerType.TryGetValue(clrBinding, out SyntaxKind keyword))
{
return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(keyword)));
}
if (IsNullableValueType(clrBinding.GetTypeInfo(), out Type underlyingValueType))
{
var context = CodeGeneratorContext.GetContextOrThrow();
return(SyntaxFactory.NullableType(GetTypeNameSyntax(context.FindType(underlyingValueType))));
}
}
return(GetTypeFullNameSyntax(type));
}
private static async Task <Document> ChangeToImmutableArrayCreateRange(
ObjectCreationExpressionSyntax objectCreation,
InitializerExpressionSyntax initializer,
INamedTypeSymbol immutableArrayType,
ITypeSymbol elementType,
Document document,
CancellationToken cancellationToken)
{
var generator = SyntaxGenerator.GetGenerator(document);
var arrayElementType = (TypeSyntax)generator.TypeExpression(elementType);
var arrayType = SyntaxFactory.ArrayType(arrayElementType,
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
var arrayCreationExpression = SyntaxFactory.ArrayCreationExpression(
type: arrayType,
initializer: SyntaxFactory.InitializerExpression(
kind: SyntaxKind.ArrayInitializerExpression,
expressions: initializer.Expressions))
.WithAdditionalAnnotations(Formatter.Annotation);
var type = generator.TypeExpression(immutableArrayType);
var memberAccess = generator.MemberAccessExpression(type, "CreateRange");
var invocation = generator.InvocationExpression(memberAccess, arrayCreationExpression);
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = oldRoot.ReplaceNode(objectCreation, invocation);
return(document.WithSyntaxRoot(newRoot));
}
public static ExpressionSyntax ImplicitlyTyped(ITypeSymbol typeSymbol, SemanticModel model, HashSet <string> visitedTypes, IFrameworkSet frameworkSet)
{
if (typeSymbol is INamedTypeSymbol namedTypeSymbol && namedTypeSymbol.TypeArguments.Length > 0)
{
var targetType = namedTypeSymbol.TypeArguments[0];
if (visitedTypes.Contains(targetType.ToFullName()))
{
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(targetType.ToTypeSyntax(frameworkSet.Context))));
}
return(SyntaxFactory.ImplicitArrayCreationExpression(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
new SyntaxNodeOrToken[]
{
AssignmentValueHelper.GetDefaultAssignmentValue(targetType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(targetType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(targetType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
}))));
}
return(AssignmentValueHelper.GetDefaultAssignmentValue(typeSymbol, model, frameworkSet));
}
public override TypeSyntax VisitArrayType(IArrayTypeSymbol symbol)
{
ThrowIfNameOnly();
var underlyingNonArrayType = symbol.ElementType;
while (underlyingNonArrayType.Kind == SymbolKind.ArrayType)
{
underlyingNonArrayType = ((IArrayTypeSymbol)underlyingNonArrayType).ElementType;
}
var elementTypeSyntax = underlyingNonArrayType.GenerateTypeSyntax();
var ranks = new List <ArrayRankSpecifierSyntax>();
var arrayType = symbol;
while (arrayType != null)
{
ranks.Add(SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SeparatedList(Enumerable.Repeat <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression(), arrayType.Rank))));
arrayType = arrayType.ElementType as IArrayTypeSymbol;
}
var arrayTypeSyntax = SyntaxFactory.ArrayType(elementTypeSyntax, ranks.ToSyntaxList());
return(AddInformationTo(arrayTypeSyntax, symbol));
}
public static ExpressionSyntax Byte()
{
return(SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.ByteKeyword)))
.WithRankSpecifiers(
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))))
.WithInitializer(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
new SyntaxNodeOrToken[]
{
Generate.Literal((byte)ValueGenerationStrategyFactory.Random.Next(255)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
Generate.Literal((byte)ValueGenerationStrategyFactory.Random.Next(255)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
Generate.Literal((byte)ValueGenerationStrategyFactory.Random.Next(255)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
Generate.Literal((byte)ValueGenerationStrategyFactory.Random.Next(255)),
}))));
}
public static IEnumerable <MemberDeclarationSyntax> GenerateGetColumns(SqModelMeta meta)
{
return(meta.Properties.First()
.Column.Select(tableColumn =>
{
var arrayItems = meta.Properties.Select(p => p.Column.First())
.Select(p => SyntaxFactory.IdentifierName("table").MemberAccess(p.ColumnName));
var arrayType = SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName(nameof(TableColumn)),
new SyntaxList <ArrayRankSpecifierSyntax>(new[]
{
SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenBracketToken),
new SeparatedSyntaxList <ExpressionSyntax>(),
SyntaxFactory.Token(SyntaxKind.CloseBracketToken))
}));
var array = SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression,
new SeparatedSyntaxList <ExpressionSyntax>().AddRange(arrayItems))
);
return SyntaxFactory
.MethodDeclaration(arrayType, MethodNameGetColumns)
.WithModifiers(Modifiers(SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword))
.AddParameterListParameters(FuncParameter("table", tableColumn.TableRef.TableTypeName))
.WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(
array
)));
}));
}
public static TypeSyntax ToTypeSyntax(this Type t)
{
if (t == typeof(void))
{
return(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)));
}
if (t.IsGenericParameter)
{
return(SyntaxFactory.IdentifierName(t.Name));
}
if (t.IsArray)
{
return(SyntaxFactory.ArrayType(
t.GetElementType().ToTypeSyntax(),
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))));
}
TypeSyntax qualification = t.IsNested
? t.DeclaringType.ToTypeSyntax()
: t.Namespace.Split('.').Select(s => (NameSyntax)SyntaxFactory.IdentifierName(s)).Aggregate((acc, next) => SyntaxFactory.QualifiedName(acc, (SimpleNameSyntax)next));
SimpleNameSyntax name = t.IsGenericType
? SyntaxFactory.GenericName(t.Name.Substring(0, t.Name.IndexOf('`', StringComparison.Ordinal)))
.WithTypeArgumentList(SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(t.GetGenericArguments().Select(ToTypeSyntax))))
: (SimpleNameSyntax)SyntaxFactory.IdentifierName(t.Name);
return(SyntaxFactory.QualifiedName((NameSyntax)qualification, name));
}
public static ExpressionSyntax ImplicitlyTypedArray(ITypeSymbol typeSymbol, SemanticModel model, HashSet <string> visitedTypes, IFrameworkSet frameworkSet)
{
if (typeSymbol is IArrayTypeSymbol arrayTypeSymbol)
{
if (visitedTypes.Contains(arrayTypeSymbol.ElementType.ToFullName()))
{
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(arrayTypeSymbol.ElementType.ToTypeSyntax(frameworkSet.Context))));
}
return(SyntaxFactory.ImplicitArrayCreationExpression(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
new SyntaxNodeOrToken[]
{
AssignmentValueHelper.GetDefaultAssignmentValue(arrayTypeSymbol.ElementType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(arrayTypeSymbol.ElementType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(arrayTypeSymbol.ElementType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
}))));
}
var random = ValueGenerationStrategyFactory.Random;
return(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Array"),
SyntaxFactory.IdentifierName("CreateInstance")))
.WithArgumentList(
Generate.Arguments(SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName("int")), Generate.Literal(random.Next(int.MaxValue)), Generate.Literal(random.Next(int.MaxValue)), Generate.Literal(random.Next(int.MaxValue)))));
}
/// <summary>
/// Initializes a new instance of the <see cref="PreviousDataField"/> class.
/// </summary>
public PreviousDataField()
{
// Initialize the object.
this.Name = "previousData";
// /// <summary>
// /// The previous contents of the record.
// /// </summary>
// private object[] previousData;
this.Syntax = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.ArrayType(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.ObjectKeyword)))
.WithRankSpecifiers(
SyntaxFactory.SingletonList <ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("previousData")))))
.WithModifiers(PreviousDataField.Modifiers)
.WithLeadingTrivia(PreviousDataField.DocumentationComment);
}
private static async Task <Solution> Replace(
Document document,
AceSyntax node,
CancellationToken cancellationToken)
{
var solution = document.Project.Solution;
var root = await document.GetSyntaxRootAsync(cancellationToken)
.ConfigureAwait(false);
if (root is null)
{
return(solution);
}
var newSpecifiers = new[] { node.Type.RankSpecifiers.Last() };
var newType = SyntaxFactory.ArrayType(
SyntaxFactory.OmittedTypeArgument(),
SyntaxFactory.List(newSpecifiers));
var newNode = node.WithType(newType);
var newRoot = root.ReplaceNode(node, newNode);
if (newRoot is null)
{
return(solution);
}
var workspace = solution.Workspace;
var formattedNode = Formatter.Format(
newRoot,
Formatter.Annotation,
workspace,
workspace.Options);
return(solution.WithDocumentSyntaxRoot(
document.Id, formattedNode));
}
public override ExpressionSyntax Visit(ConversionContext context, ArrayCreationExpr expr)
{
var type = TypeHelper.ConvertTypeOf(expr);
var rankDimensions = expr.getDimensions().ToList <Expression>();
var initializer = expr.getInitializer();
var rankSyntaxes = new List <ExpressionSyntax>();
if (rankDimensions != null)
{
rankSyntaxes.AddRange(rankDimensions.Select(dimension => VisitExpression(context, dimension)));
}
if (initializer == null)
{
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(SyntaxFactory.ParseTypeName(type)))
.AddTypeRankSpecifiers(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(rankSyntaxes, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), rankSyntaxes.Count - 1)))));
}
// todo: support multi-dimensional and jagged arrays
var values = initializer.getValues().ToList <Expression>();
var syntaxes = values.Select(value => VisitExpression(context, value)).ToList();
var initSyntax =
syntaxes.Any() ?
SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, SyntaxFactory.SeparatedList(syntaxes, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), syntaxes.Count - 1))) :
SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression);
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(SyntaxFactory.ParseTypeName(type)), initSyntax));
}
public CodeTemplateBuilder UseParameterType(Type type, int parameterCount, bool isArray = false)
{
var parameterListNode = _template.GetAnnotatedNodes("ParameterList").First();
var parameterList = new ParameterSyntax[parameterCount];
for (int i = 0; i < parameterList.Length; i++)
{
if (isArray)
{
SyntaxFactory.Parameter(
SyntaxFactory.Identifier(((char)('a' + i)).ToString()))
.WithType(
SyntaxFactory.ArrayType(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(GetTypeSyntax(type))))
.WithRankSpecifiers(
SyntaxFactory.SingletonList <ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))));
}
else
{
parameterList[i] = SyntaxFactory.Parameter(SyntaxFactory.Identifier(((char)('a' + i)).ToString()))
.WithType(SyntaxFactory.PredefinedType(
SyntaxFactory.Token(GetTypeSyntax(type))));
}
}
_template = _template.ReplaceNode(parameterListNode, SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameterList)));
return(this);
}
public void Exception(string name, MethodDefinitionFactory factory)
{
var methodSyntax =
SyntaxFactory.MethodDeclaration(
SyntaxFactory.ArrayType(SyntaxFactory.GenericName(CreateSyntaxIdentifierToken(name))), name);
Assert.Throws <NotImplementedException>(() => factory.CreateMethodFromSyntax(methodSyntax));
}
public override SyntaxNode MakeSyntaxNode()
{
var res = SyntaxFactory.ArrayType(ElementType, RankSpecifiers);
// if (IsVar != null) res = res.WithIsVar(IsVar);
IsChanged = false;
return(res);
}
internal static ParameterListSyntax CreateParamsElementArrayParameters(MetaField field)
{
return(SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Parameter(ValuesParameterName.Identifier)
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ParamsKeyword)))
.WithType(SyntaxFactory.ArrayType(GetFullyQualifiedSymbolName(field.ElementType))
.AddRankSpecifiers(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression())))))));
}
public override sealed async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var name = root.FindNode(diagnosticSpan) as ModifiedIdentifierSyntax;
if (name == null)
{
return;
}
var variableDeclarator = name.Parent as VariableDeclaratorSyntax;
if (variableDeclarator == null ||
variableDeclarator.Names.Count != 1)
{
return;
}
var simpleAsClause = variableDeclarator.AsClause as SimpleAsClauseSyntax;
if (simpleAsClause == null)
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var type = simpleAsClause.Type.WithoutTrivia();
var typeAsArrayType = type as ArrayTypeSyntax;
var rankSpecifiers = name.ArrayRankSpecifiers.Select(rank => rank.WithoutTrivia());
var newType = typeAsArrayType == null
? SyntaxFactory.ArrayType(
type,
SyntaxFactory.List(rankSpecifiers))
: typeAsArrayType.AddRankSpecifiers(rankSpecifiers.ToArray());
newType = newType.WithTriviaFrom(simpleAsClause.Type);
var newVariableDeclarator = variableDeclarator
.WithNames(SyntaxFactory.SeparatedList(new[] {
SyntaxFactory.ModifiedIdentifier(name.Identifier, name.ArrayBounds).WithTriviaFrom(name)
}))
.WithAsClause(simpleAsClause.WithType(newType));
var newRoot = root.ReplaceNode(
variableDeclarator,
newVariableDeclarator);
return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot)));
}),
context.Diagnostics);
}
public override TypeSyntax VisitArrayType(IArrayTypeSymbol symbol)
{
ThrowIfNameOnly();
ITypeSymbol underlyingType = symbol;
while (underlyingType is IArrayTypeSymbol innerArray)
{
underlyingType = innerArray.ElementType;
#if !CODE_STYLE // TODO: Remove the #if once NullableAnnotation is available.
// https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
if (underlyingType.NullableAnnotation == NullableAnnotation.Annotated)
{
// If the inner array we just moved to is also nullable, then
// we must terminate the digging now so we produce the syntax for that,
// and then append the ranks we passed through at the end. This is because
// nullability annotations acts as a "barrier" where we won't reorder array
// through. So whereas:
//
// string[][,]
//
// is really an array of rank 1 that has an element of rank 2,
//
// string[]?[,]
//
// is really an array of rank 2 that has nullable elements of rank 1.
break;
}
#endif
}
var elementTypeSyntax = underlyingType.GenerateTypeSyntax();
var ranks = new List <ArrayRankSpecifierSyntax>();
var arrayType = symbol;
while (arrayType != null && !arrayType.Equals(underlyingType))
{
ranks.Add(SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SeparatedList(Enumerable.Repeat <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression(), arrayType.Rank))));
arrayType = arrayType.ElementType as IArrayTypeSymbol;
}
TypeSyntax arrayTypeSyntax = SyntaxFactory.ArrayType(elementTypeSyntax, ranks.ToSyntaxList());
#if !CODE_STYLE // TODO: Remove the #if once NullableAnnotation is available.
// https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
if (symbol.NullableAnnotation == NullableAnnotation.Annotated)
{
arrayTypeSyntax = SyntaxFactory.NullableType(arrayTypeSyntax);
}
#endif
return(AddInformationTo(arrayTypeSyntax, symbol));
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
var entryType = MyVisualScriptingProxy.GetType(ObjectBuilder.Type);
var listType = typeof(List <>).MakeGenericType(entryType);
var separatedList = new List <SyntaxNodeOrToken>();
// Create source of arguments for array creation syntax
for (var index = 0; index < ObjectBuilder.DefaultEntries.Count; index++)
{
var entry = ObjectBuilder.DefaultEntries[index];
var literal = MySyntaxFactory.Literal(ObjectBuilder.Type, entry);
separatedList.Add(literal);
if (index < ObjectBuilder.DefaultEntries.Count - 1)
{
separatedList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
}
// Syntax of "new Type[]{arg0, arg1, ...}"
ArrayCreationExpressionSyntax arrayCreationSyntax = null;
if (separatedList.Count > 0)
{
arrayCreationSyntax = SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName(ObjectBuilder.Type),
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression()
)
)
)
),
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
separatedList
)
)
);
}
// Syntax of new List<Type>(arrayCreationSyntax);
var listCreationSyntax = MySyntaxFactory.GenericObjectCreation(listType, arrayCreationSyntax == null ? null : new[] { arrayCreationSyntax });
var localVariableSyntax = MySyntaxFactory.LocalVariable(listType, VariableSyntaxName(), listCreationSyntax);
expressions.Add(localVariableSyntax);
}
private VariableDeclarationSyntax Transpile(JassArrayDeclaratorSyntax arrayDeclarator)
{
var type = Transpile(arrayDeclarator.Type);
return(SyntaxFactory.VariableDeclaration(
SyntaxFactory.ArrayType(type),
SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(
Transpile(arrayDeclarator.IdentifierName),
null,
SyntaxFactory.EqualsValueClause(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(type)))))));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.ChangeTypeOfParamsParameter))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
ParameterSyntax parameter = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <ParameterSyntax>();
Debug.Assert(parameter != null, $"{nameof(parameter)} is null");
if (parameter == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.ParamsParameterMustBeSingleDimensionalArray:
{
TypeSyntax type = parameter.Type;
if (type?.IsMissing == false)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(type, context.CancellationToken);
if (typeSymbol?.IsNamedType() == true)
{
ArrayTypeSyntax newType = SyntaxFactory.ArrayType(
typeSymbol.ToMinimalTypeSyntax(semanticModel, parameter.SpanStart),
SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier()));
CodeAction codeAction = CodeAction.Create(
$"Change parameter type to '{newType}'",
cancellationToken => context.Document.ReplaceNodeAsync(type, newType.WithTriviaFrom(type), cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
break;
}
}
}
}
protected ExpressionSyntax GetCompiledBindingCreation(DefaultViewCompilerCodeEmitter emitter, string methodName, string updateMethodName, string originalString, ExpressionSyntax[] actionFilters, string javascript, string id)
{
var dict = new Dictionary <string, ExpressionSyntax>();
if (methodName != null)
{
dict.Add(nameof(CompiledBindingExpression.Delegate), SyntaxFactory.ParseName(methodName));
}
if (updateMethodName != null)
{
dict.Add(nameof(CompiledBindingExpression.UpdateDelegate), SyntaxFactory.ParseName(updateMethodName));
}
if (originalString != null)
{
dict.Add(nameof(CompiledBindingExpression.OriginalString), emitter.EmitValue(originalString));
}
if (javascript != null)
{
dict.Add(nameof(CompiledBindingExpression.Javascript), emitter.EmitValue(javascript));
}
if (id != null)
{
dict.Add(nameof(CompiledBindingExpression.Id), emitter.EmitValue(id));
}
if (actionFilters != null)
{
dict.Add(nameof(CompiledBindingExpression.ActionFilters),
SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(SyntaxFactory.ParseTypeName(typeof(ActionFilterAttribute).FullName))
.WithRankSpecifiers(
SyntaxFactory.SingletonList <ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))),
SyntaxFactory.InitializerExpression(SyntaxKind.CollectionInitializerExpression,
SyntaxFactory.SeparatedList(actionFilters))));
}
return(SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.ParseTypeName(typeof(CompiledBindingExpression).FullName),
SyntaxFactory.ArgumentList(),
SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression,
SyntaxFactory.SeparatedList(
dict.Select(p =>
(ExpressionSyntax)SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(p.Key),
p.Value
)
)
)
)
));
}
public override ExpressionSyntax Visit(ConversionContext context, ArrayCreationExpr expr)
{
var type = TypeHelper.ConvertType(expr.getType().toString());
var rankDimensions = expr.getDimensions().ToList <Expression>();
var initializer = expr.getInitializer();
var rankSyntaxes = new List <ExpressionSyntax>();
if (rankDimensions != null)
{
foreach (var dimension in rankDimensions)
{
var rankSyntax = ExpressionVisitor.VisitExpression(context, dimension);
rankSyntaxes.Add(rankSyntax);
}
}
var elementType = TypeHelper.GetTypeSyntax(type);
if (initializer == null)
{
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(elementType))
.AddTypeRankSpecifiers(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(rankSyntaxes, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), rankSyntaxes.Count - 1)))));
}
// todo: support multi-dimensional and jagged arrays
var values = initializer.getValues().ToList <Expression>();
//// empty array
if (values.Count <= 0)
{
var rankSpecifiers = SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression())));
var initializerExpression = SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression);
var arrayCreationExpression = SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(SyntaxFactory.ArrayType(elementType))
.WithRankSpecifiers(rankSpecifiers))
.WithInitializer(initializerExpression);
return(arrayCreationExpression);
}
var syntaxes = new List <ExpressionSyntax>();
foreach (var value in values)
{
var syntax = ExpressionVisitor.VisitExpression(context, value);
syntaxes.Add(syntax);
}
var initSyntax = SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, SyntaxFactory.SeparatedList(syntaxes, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), syntaxes.Count - 1)));
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(elementType), initSyntax));
}
public override TypeSyntax VisitArrayType(IArrayTypeSymbol symbol)
{
ThrowIfNameOnly();
ITypeSymbol underlyingType = symbol;
while (underlyingType is IArrayTypeSymbol innerArray)
{
underlyingType = innerArray.ElementType;
if (underlyingType.NullableAnnotation == NullableAnnotation.Annotated)
{
// If the inner array we just moved to is also nullable, then
// we must terminate the digging now so we produce the syntax for that,
// and then append the ranks we passed through at the end. This is because
// nullability annotations acts as a "barrier" where we won't reorder array
// through. So whereas:
//
// string[][,]
//
// is really an array of rank 1 that has an element of rank 2,
//
// string[]?[,]
//
// is really an array of rank 2 that has nullable elements of rank 1.
break;
}
}
var elementTypeSyntax = underlyingType.GenerateTypeSyntax();
using var _ = ArrayBuilder <ArrayRankSpecifierSyntax> .GetInstance(out var ranks);
var arrayType = symbol;
while (arrayType != null && !arrayType.Equals(underlyingType))
{
ranks.Add(SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SeparatedList(Enumerable.Repeat <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression(), arrayType.Rank))));
arrayType = arrayType.ElementType as IArrayTypeSymbol;
}
TypeSyntax arrayTypeSyntax = SyntaxFactory.ArrayType(elementTypeSyntax, ranks.ToSyntaxList());
if (symbol.NullableAnnotation == NullableAnnotation.Annotated)
{
arrayTypeSyntax = SyntaxFactory.NullableType(arrayTypeSyntax);
}
return(AddInformationTo(arrayTypeSyntax, symbol));
}
public static TypeSyntax ToTypeSyntax(this Type typeToConvert)
{
TypeSyntax ts;
if (typeToConvert.IsArray)
{
var elementTypeSyntax = typeToConvert.GetElementType().ToTypeSyntax();
ts = SyntaxFactory.ArrayType(elementTypeSyntax)
.WithRankSpecifiers(
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression()))));
}
else if (typeToConvert.IsGenericType)
{
TypeArgumentListSyntax typeArgumentListSyntax = GenerateGenericTypeArgumentList(typeToConvert);
string genericTypeName;
if (!typeToConvert.IsVsArrayType())
{
genericTypeName = GetFriendlyTypeName(typeToConvert);
}
else
{
genericTypeName = k_VSArrayReplacingTypeFriendlyName;
}
ts = SyntaxFactory.GenericName(SyntaxFactory.Identifier(genericTypeName))
.WithTypeArgumentList(typeArgumentListSyntax);
}
else
{
var roslynPredefKind = KindFromType(typeToConvert);
if (roslynPredefKind != SyntaxKind.None)
{
ts = SyntaxFactory.PredefinedType(SyntaxFactory.Token(roslynPredefKind));
}
else
{
if (typeToConvert.IsNested)
{
ts = SyntaxFactory.QualifiedName(SyntaxFactory.ParseName(typeToConvert.DeclaringType.FullName), SyntaxFactory.IdentifierName(typeToConvert.Name));
}
else
{
ts = SyntaxFactory.ParseTypeName(typeToConvert.FullName);
}
}
}
return(ts);
}
private TypeSyntax GetPropertyType(ITypeSymbol type)
{
if (type.TypeKind == TypeKind.Array)
{
var arrayType = (IArrayTypeSymbol)type;
var elementName = arrayType.ElementType.Name == "XmlElement" ? "XElement" : GetTypeName(arrayType.ElementType);
var elementType = SyntaxFactory.ParseTypeName(elementName);
return(SyntaxFactory.ArrayType(elementType).AddRankSpecifiers(SyntaxFactory.ArrayRankSpecifier()));
}
var typeName = type.Name == "XmlElement" ? "XElement" : GetTypeName(type);
return(SyntaxFactory.ParseTypeName(typeName));
}
private static MemberDeclarationSyntax[] GenerateMethods(IReadOnlyList <TableModel> tables, string tablePrefix)
{
var result = new List <MemberDeclarationSyntax>(tables.Count * 2 + 2);
var identifierAliasType = SyntaxFactory.IdentifierName(nameof(Alias));
var arrayItems = tables.Select(t => SyntaxFactory.IdentifierName(GetMethodName(t, tablePrefix)).Invoke(identifierAliasType.MemberAccess(nameof(Alias.Empty))));
var arrayType = SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(nameof(TableBase)),
new SyntaxList <ArrayRankSpecifierSyntax>(new[]
{
SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenBracketToken),
new SeparatedSyntaxList <ExpressionSyntax>(),
SyntaxFactory.Token(SyntaxKind.CloseBracketToken))
}));
var array = SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression,
new SeparatedSyntaxList <ExpressionSyntax>().AddRange(arrayItems))
);
result.Add(
SyntaxFactory.MethodDeclaration(arrayType, "BuildAllTableList")
.WithModifiers(SyntaxHelpers.Modifiers(SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword))
.WithExpressionBody(SyntaxFactory.ArrowExpressionClause(
array
))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
foreach (var t in tables)
{
var aliasParamName = "alias";
result.Add(SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(t.Name), GetMethodName(t, tablePrefix))
.WithModifiers(SyntaxHelpers.Modifiers(SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword))
.AddParameterListParameters(SyntaxHelpers.FuncParameter(aliasParamName, nameof(Alias)))
.WithExpressionBody(SyntaxFactory.ArrowExpressionClause(
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(t.Name),
SyntaxHelpers.ArgumentList(SyntaxFactory.IdentifierName(aliasParamName)),
null)))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
result.Add(SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(t.Name), GetMethodName(t, tablePrefix))
.WithModifiers(SyntaxHelpers.Modifiers(SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword))
.WithExpressionBody(SyntaxFactory.ArrowExpressionClause(
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(t.Name),
SyntaxHelpers.ArgumentList(identifierAliasType.MemberAccess(nameof(Alias.Auto))),
null)))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
}
return(result.ToArray());
public ExpressionSyntax EmitCreateArray(Type arrayType, IEnumerable values)
{
return(SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(
ParseTypeName(arrayType),
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))),
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(
values.Cast <object>().Select(EmitValue)))));
}
