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 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
)));
}));
}
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 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)),
}))));
}
/// <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 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 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));
}
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);
}
/// <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);
}
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 override VisualBasicSyntaxNode VisitArrayRankSpecifier(CSS.ArrayRankSpecifierSyntax node)
{
return(SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.Token(SyntaxKind.OpenParenToken),
SyntaxFactory.TokenList(Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), node.Rank - 1)),
SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
}
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));
}
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 SyntaxNode MakeSyntaxNode()
{
var res = SyntaxFactory.ArrayRankSpecifier(OpenBracketToken, Sizes, CloseBracketToken);
// if (Rank != null) res = res.WithRank(Rank);
IsChanged = false;
return(res);
}
public static ArrayCreationExpressionSyntax CreateArray(ArrayTypeSyntax arrayType, ValueBridge size)
{
var rankSpecifiers = arrayType.RankSpecifiers;
var newRankSpecifiers = rankSpecifiers.Select((x, i)
=> i == 0 ? SyntaxFactory.ArrayRankSpecifier(SyntaxFactoryHelper.CreateSeparatedList((ExpressionSyntax)size)) : x);
return(SyntaxFactory.ArrayCreationExpression(
arrayType.WithRankSpecifiers(new SyntaxList <ArrayRankSpecifierSyntax>(newRankSpecifiers))));
}
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);
}
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;
}
}
}
}
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));
}
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 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)))));
}
//OmittedArraySizeExpression case only:
public static SyntaxNode MkCSharpArrayCreationExpression(string type, SyntaxNodeOrToken[] initializer)
{
return(SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(type))
.WithRankSpecifiers(
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))))
.WithInitializer(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(initializer))));
}
/// <summary>
/// Converts a <see cref="Type"/> to a <see cref="TypeSyntax"/>.
/// </summary>
/// <param name="t">The type</param>
/// <param name="useGlobalAlias">Whether the to qualify type names with "global::"</param>
/// <returns>A <see cref="TypeSyntax"/> representing the type.</returns>
public static TypeSyntax ToTypeSyntax(this Type t, bool useGlobalAlias = false)
{
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(useGlobalAlias),
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))));
}
if (t.IsPointer)
{
return(SyntaxFactory.PointerType(t.GetElementType().ToTypeSyntax(useGlobalAlias)));
}
TypeSyntax qualification = t.IsNested
? t.DeclaringType.ToTypeSyntax(useGlobalAlias)
: t.Namespace.Split('.')
.Select(s => (NameSyntax)SyntaxFactory.IdentifierName(s))
.Aggregate((acc, next) =>
{
// see if we should qualify with global::
NameSyntax left = useGlobalAlias && acc is IdentifierNameSyntax identifier
? SyntaxFactory.AliasQualifiedName(SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword)), identifier)
: acc;
return(SyntaxFactory.QualifiedName(left, (SimpleNameSyntax)next));
});
SimpleNameSyntax name = t.IsGenericType
? SyntaxFactory.GenericName(t.Name.Substring(0, t.Name.IndexOf('`', StringComparison.Ordinal)))
.WithTypeArgumentList(SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(t.GenericTypeArguments.Select(typeArg => typeArg.ToTypeSyntax(useGlobalAlias)))))
: (SimpleNameSyntax)SyntaxFactory.IdentifierName(t.Name);
return(SyntaxFactory.QualifiedName((NameSyntax)qualification, name));
}
protected virtual InterfaceDeclarationSyntax AddJsonConverter(InterfaceDeclarationSyntax target,
OpenApiEnrichmentContext <OpenApiSchema> context)
{
OpenApiSchema schema = context.Element;
var attribute = SyntaxFactory.Attribute(NewtonsoftJsonTypes.JsonConverterAttributeName).AddArgumentListArguments(
SyntaxFactory.AttributeArgument(
SyntaxFactory.TypeOfExpression(JsonSerializationNamespace.DiscriminatorConverter)),
SyntaxFactory.AttributeArgument(
SyntaxHelpers.StringLiteral(schema.Discriminator.PropertyName)),
SyntaxFactory.AttributeArgument(
SyntaxFactory.TypeOfExpression(Context.TypeGeneratorRegistry.Get(context.LocatedElement).TypeInfo.Name)));
if (schema.Discriminator.Mapping != null)
{
var paramArray = SyntaxFactory.ArrayCreationExpression(
SyntaxFactory
.ArrayType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)))
.WithRankSpecifiers(
SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))))
.WithInitializer(SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
schema.Discriminator.Mapping
.SelectMany(mapping =>
{
// Add two parameters to the object array for each mapping
// First is the string key of the mapping, second is the Type to deserialize
OpenApiSchema referencedSchema = schema.OneOf
.FirstOrDefault(p => p.Reference?.ReferenceV3 == mapping.Value);
return(referencedSchema != null
? new ExpressionSyntax[]
{
SyntaxHelpers.StringLiteral(mapping.Key), SyntaxFactory.TypeOfExpression(
Context.TypeGeneratorRegistry.Get(
referencedSchema.CreateRoot(referencedSchema.Reference.Id)).TypeInfo.Name)
}
: Enumerable.Empty <ExpressionSyntax>());
}))));
attribute = attribute.AddArgumentListArguments(SyntaxFactory.AttributeArgument(paramArray));
}
return(target.AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(attribute)));
}
/// <summary>
/// Translates the given type into a type syntax.
/// </summary>
/// <param name="columnType">The column's type.</param>
/// <returns>A Roslyn type syntax corresponding to the CLR type.</returns>
public static TypeSyntax FromType(ColumnType columnType)
{
// Validate the parameter
if (columnType == null)
{
throw new ArgumentNullException(nameof(columnType));
}
if (columnType.IsNullable && columnType.IsValueType)
{
TypeSyntax nullableTypeSyntax = null;
if (!Conversions.PredefinedTypes.TryGetValue(columnType.FullName, out nullableTypeSyntax))
{
nullableTypeSyntax = SyntaxFactory.IdentifierName(columnType.FullName);
}
return(SyntaxFactory.NullableType(nullableTypeSyntax));
}
if (columnType.IsArray)
{
TypeSyntax arrayTypeSyntax = null;
if (!Conversions.PredefinedTypes.TryGetValue(columnType.FullName, out arrayTypeSyntax))
{
arrayTypeSyntax = SyntaxFactory.IdentifierName(columnType.FullName);
}
return(SyntaxFactory.ArrayType(arrayTypeSyntax)
.WithRankSpecifiers(
SyntaxFactory.SingletonList <ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression()
.WithOmittedArraySizeExpressionToken(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)))))));
}
TypeSyntax typeSyntax = null;
if (!Conversions.PredefinedTypes.TryGetValue(columnType.FullName, out typeSyntax))
{
typeSyntax = SyntaxFactory.IdentifierName(columnType.FullName);
}
return(typeSyntax);
}
private static ArrayCreationExpressionSyntax GetArrayCreationExpression(IEnumerable <string> items)
{
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)))
.WithRankSpecifiers(
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression()
.WithOmittedArraySizeExpressionToken(
SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken))))
.WithOpenBracketToken(SyntaxFactory.Token(SyntaxKind.OpenBracketToken))
.WithCloseBracketToken(SyntaxFactory.Token(SyntaxKind.CloseBracketToken)))))
.WithNewKeyword(SyntaxFactory.Token(SyntaxKind.NewKeyword))
.WithInitializer(SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(items.Select(
x =>
SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(x)))))
.WithOpenBraceToken(SyntaxFactory.Token(SyntaxKind.OpenBraceToken))
.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken))));
}
