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