private CSharpSyntaxNode GetInitializerFromNameAndType(ITypeSymbol typeSymbol, ModifiedIdentifierSyntax name, CSharpSyntaxNode initializer) { if (!SyntaxTokenExtensions.IsKind(name.Nullable, SyntaxKind.None)) { if (typeSymbol.IsArrayType()) { initializer = null; } } var rankSpecifiers = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, false); if (rankSpecifiers.Count > 0) { var rankSpecifiersWithSizes = ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds); if (!rankSpecifiersWithSizes.SelectMany(ars => ars.Sizes).OfType <OmittedArraySizeExpressionSyntax>().Any()) { var arrayTypeSyntax = (ArrayTypeSyntax)CsSyntaxGenerator.TypeExpression(typeSymbol); arrayTypeSyntax = arrayTypeSyntax.WithRankSpecifiers(rankSpecifiersWithSizes); initializer = SyntaxFactory.ArrayCreationExpression(arrayTypeSyntax); } } return(initializer); }
public TypeSyntax GetTypeSyntax(ITypeSymbol typeSymbol, bool useImplicitType = false) { if (useImplicitType || typeSymbol == null) { return(CreateVarTypeName()); } return((TypeSyntax)CsSyntaxGenerator.TypeExpression(typeSymbol)); }
public TypeSyntax GetTypeSyntax(ITypeSymbol typeSymbol, bool useImplicitType = false) { if (useImplicitType || typeSymbol == null) { return(ValidSyntaxFactory.VarType); } var syntax = (TypeSyntax)CsSyntaxGenerator.TypeExpression(typeSymbol); return(WithDeclarationCasing(syntax, typeSymbol)); }
private TypeSyntax GetFuncTypeSyntax(IMethodSymbol method) { var parameters = method.Parameters.Select(p => p.Type).ToArray(); if (method.ReturnsVoid) { return(parameters.Any() ? (TypeSyntax)CsSyntaxGenerator.GenericName(nameof(Action), parameters) : SyntaxFactory.ParseTypeName("Action")); } parameters = parameters.Concat(new[] { method.ReturnType }).ToArray(); return((TypeSyntax)CsSyntaxGenerator.GenericName(nameof(Func <object>), parameters)); }
public (IReadOnlyCollection <VariableDeclarationSyntax> Variables, IReadOnlyCollection <CSharpSyntaxNode> Methods) SplitVariableDeclarations( VariableDeclaratorSyntax declarator, bool preferExplicitType = false) { var vbInitValue = GetInitializerToConvert(declarator); var initializerOrMethodDecl = vbInitValue?.Accept(TriviaConvertingExpressionVisitor); var vbInitializerType = vbInitValue != null?_semanticModel.GetTypeInfo(vbInitValue).Type : null; bool requireExplicitTypeForAll = false; IMethodSymbol initSymbol = null; if (vbInitValue != null) { var vbInitConstantValue = _semanticModel.GetConstantValue(vbInitValue); var vbInitIsNothingLiteral = vbInitConstantValue.HasValue && vbInitConstantValue.Value == null; preferExplicitType |= vbInitializerType != null && vbInitializerType.HasCsKeyword(); initSymbol = _semanticModel.GetSymbolInfo(vbInitValue).Symbol as IMethodSymbol; bool isAnonymousFunction = initSymbol?.IsAnonymousFunction() == true; requireExplicitTypeForAll = vbInitIsNothingLiteral || isAnonymousFunction; } var csVars = new Dictionary <string, VariableDeclarationSyntax>(); var csMethods = new List <CSharpSyntaxNode>(); foreach (var name in declarator.Names) { var declaredSymbol = _semanticModel.GetDeclaredSymbol(name); var declaredSymbolType = declaredSymbol.GetSymbolType(); var requireExplicitType = requireExplicitTypeForAll || vbInitializerType != null && !Equals(declaredSymbolType, vbInitializerType); var csTypeSyntax = (TypeSyntax)CsSyntaxGenerator.TypeExpression(declaredSymbolType); bool isField = declarator.Parent.IsKind(SyntaxKind.FieldDeclaration); EqualsValueClauseSyntax equalsValueClauseSyntax; if (GetInitializerFromNameAndType(declaredSymbolType, name, initializerOrMethodDecl) is ExpressionSyntax adjustedInitializerExpr) { var convertedInitializer = vbInitValue != null?TypeConversionAnalyzer.AddExplicitConversion(vbInitValue, adjustedInitializerExpr) : adjustedInitializerExpr; equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer); } else if (isField || _semanticModel.IsDefinitelyAssignedBeforeRead(declaredSymbol, name)) { equalsValueClauseSyntax = null; } else { // VB initializes variables to their default equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(csTypeSyntax)); } var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax); string k = declaredSymbolType.GetFullMetadataName(); if (csVars.TryGetValue(k, out var decl)) { csVars[k] = decl.AddVariables(v); } else { if (initializerOrMethodDecl == null || initializerOrMethodDecl is ExpressionSyntax) { bool useVar = equalsValueClauseSyntax != null && !preferExplicitType && !requireExplicitType; var typeSyntax = initSymbol == null || !initSymbol.IsAnonymousFunction() ? GetTypeSyntax(declaredSymbolType, useVar) : GetFuncTypeSyntax(initSymbol); csVars[k] = SyntaxFactory.VariableDeclaration(typeSyntax, SyntaxFactory.SingletonSeparatedList(v)); } else { csMethods.Add(initializerOrMethodDecl); } } } return(csVars.Values, csMethods); }