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 void Go(OutputWriter writer, InitializerExpressionSyntax initializer)
{
writer.WriteIndent();
var isCollectionInit = false;
if (CSharpExtensions.CSharpKind(initializer) == SyntaxKind.CollectionInitializerExpression ||
CSharpExtensions.CSharpKind(initializer) == SyntaxKind.ArrayInitializerExpression)
{
var tx = TypeProcessor.GetTypeInfo(initializer);
var t = tx.Type;
if (t == null)
t = tx.ConvertedType;
if (t != null) // Initializer within initializer
{
var elementType = t.As<IArrayTypeSymbol>().ElementType;
var ptr = !elementType.IsValueType; // ? "" : "";
var type = TypeProcessor.ConvertType(elementType);
var typeString = "Array_T!(" + type + ")";
if (elementType.TypeKind == TypeKind.TypeParameter)
writer.Write(" __TypeNew!(" + typeString + ")(");
else
writer.Write("new " + typeString + "(");
}
var variableDeclarationSyntax = initializer.Parent.Parent.Parent as VariableDeclarationSyntax;
if (variableDeclarationSyntax != null)
{
var atype = variableDeclarationSyntax.Type;
initializer.WriteArrayInitializer(writer, atype);
}
else
initializer.WriteArrayInitializer(writer,t);
if (t != null)
writer.Write(")");
}
else
{
// writer.Write("goto ");
// foreach (var expressionSyntax in method.Expressions)
// {
// Core.Write(writer, expressionSyntax);
// }
bool first = true;
foreach (var expression in initializer.Expressions)
{
if (first)
first = false;
else
writer.Write(", ");
Core.Write(writer, expression);
}
}
// writer.Write(";");
}
public override SyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
{
if (node.Kind() != SyntaxKind.CollectionInitializerExpression)
return node;
var initialiserExpressions = GetInitializerItems(_nameDataPairs);
var complexElementInitializerExpression = SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression, initialiserExpressions);
return complexElementInitializerExpression;
}
public static InitializerExpressionSyntax FixInitializerExpressionFormatting(this InitializerExpressionSyntax initializerExpressionSyntax, ObjectCreationExpressionSyntax objectCreationExpression)
{
var trivia = objectCreationExpression.ArgumentList?.CloseParenToken.TrailingTrivia ?? objectCreationExpression.Type.GetTrailingTrivia();
if (trivia.ToFullString().Contains(Environment.NewLine))
{
return(initializerExpressionSyntax);
}
return(initializerExpressionSyntax
.WithLeadingTrivia(SyntaxTriviaList.Create(SyntaxFactory.EndOfLine(Environment.NewLine))));
}
private CollectionCapacityConstraint GetInitializerConstraint(InitializerExpressionSyntax initializer)
{
if (initializer?.Expressions == null)
{
return(null);
}
return(initializer.Expressions.Count == 0
? CollectionCapacityConstraint.Empty // No items added through the initializer
: CollectionCapacityConstraint.NotEmpty);
}
private static Document RemoveElementInitializer(
ExpressionSyntax elementInitializer,
InitializerExpressionSyntax objectInitializer,
SyntaxNode root,
Document document)
{
var newElementInitializers = objectInitializer.Expressions.Remove(elementInitializer);
var newRoot = root.ReplaceNode(objectInitializer, objectInitializer.WithExpressions(newElementInitializers));
return(document.WithSyntaxRoot(newRoot));
}
public override void VisitInitializerExpression(InitializerExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.CollectionInitializerExpression))
{
foreach (var addExpression in node.Expressions)
{
VisitSymbol(context.SemanticModel.GetCollectionInitializerSymbolInfo(addExpression).Symbol);
}
}
base.VisitInitializerExpression(node);
}
private static bool CanExpand(
InitializerExpressionSyntax initializer,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
var objectCreationExpression = (ObjectCreationExpressionSyntax)initializer.Parent;
if (objectCreationExpression.Type != null)
{
ExpressionSyntax expression = initializer.Expressions[0];
if (expression.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
var assignment = (AssignmentExpressionSyntax)expression;
ExpressionSyntax left = assignment.Left;
if (left is ImplicitElementAccessSyntax implicitElementAccess)
{
BracketedArgumentListSyntax argumentList = implicitElementAccess.ArgumentList;
if (argumentList?.Arguments.Any() == true)
{
return(HasAccessibleIndexer(
argumentList.Arguments[0].Expression,
objectCreationExpression,
semanticModel,
cancellationToken));
}
}
else
{
return(true);
}
}
else if (expression.IsKind(SyntaxKind.ComplexElementInitializerExpression))
{
var initializerExpression = (InitializerExpressionSyntax)expression;
SeparatedSyntaxList <ExpressionSyntax> expressions = initializerExpression.Expressions;
if (expressions.Any())
{
return(HasAccessibleIndexer(expressions[0], objectCreationExpression, semanticModel, cancellationToken));
}
}
else
{
return(HasAccessibleAddMethod(expression, objectCreationExpression, semanticModel, cancellationToken));
}
}
return(false);
}
protected override IValue VisitObjectInitializerExpression(InitializerExpressionSyntax node)
{
IValue[] items = node.Expressions
.AsEnumerable()
.Select(Visit)
.Cast <CsharpAssignExpression>()
.ToArray();
var bb = new IValueTable_PseudoValue(items);
return(bb);
}
private static IEnumerable <ExpressionStatementSyntax> ExpandObjectInitializer(
InitializerExpressionSyntax initializer,
ExpressionSyntax initializedExpression)
{
foreach (ExpressionSyntax expression in initializer.Expressions)
{
if (expression.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
var assignment = (AssignmentExpressionSyntax)expression;
if (assignment.Left.IsKind(SyntaxKind.ImplicitElementAccess))
{
yield return(ExpressionStatement(
SimpleAssignmentExpression(
ElementAccessExpression(
initializedExpression,
((ImplicitElementAccessSyntax)assignment.Left).ArgumentList),
assignment.Right)));
}
else
{
yield return(ExpressionStatement(
SimpleAssignmentExpression(
SimpleMemberAccessExpression(
initializedExpression,
(IdentifierNameSyntax)assignment.Left),
assignment.Right)));
}
}
else if (expression.IsKind(SyntaxKind.ComplexElementInitializerExpression))
{
var elementInitializer = (InitializerExpressionSyntax)expression;
yield return(ExpressionStatement(
SimpleAssignmentExpression(
ElementAccessExpression(
initializedExpression,
BracketedArgumentList(SingletonSeparatedList(Argument(elementInitializer.Expressions[0])))),
elementInitializer.Expressions[1])));
}
else
{
yield return(ExpressionStatement(
InvocationExpression(
SimpleMemberAccessExpression(
initializedExpression,
IdentifierName("Add")),
ArgumentList(Argument(expression))
)
));
}
}
}
public override SyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
{
if (node.Kind() != SyntaxKind.CollectionInitializerExpression)
{
return(node);
}
var initialiserExpressions = GetInitializerItems(_icons);
var complexElementInitializerExpression = SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression, initialiserExpressions);
return(complexElementInitializerExpression);
}
private static async Task <Document> ReplaceEmptyInitializationBlock(Document document,
InitializerExpressionSyntax objectInitializer, SemanticModel semanticModel,
IMappingMatcher mappingMatcher, CancellationToken cancellationToken)
{
var oldObjCreation = objectInitializer.FindContainer <ObjectCreationExpressionSyntax>();
var createdObjectType = ModelExtensions.GetTypeInfo(semanticModel, oldObjCreation).Type;
var mappingEngine = await MappingEngine.Create(document, cancellationToken, semanticModel.FindContextAssembly(objectInitializer));
var newObjectCreation = mappingEngine.AddInitializerWithMapping(oldObjCreation, mappingMatcher, createdObjectType);
return(await document.ReplaceNodes(oldObjCreation, newObjectCreation, cancellationToken));
}
public bool Analyze(InitializerExpressionSyntax syntax)
{
if (syntax.Parent is ObjectCreationExpressionSyntax || syntax.Parent is ArrayCreationExpressionSyntax)
{
if (!(syntax.Parent.Parent is EqualsValueClauseSyntax) && !(syntax.Parent.Parent is AssignmentExpressionSyntax))
{
FireSyntaxErrorCallback(syntax, "Initializers only supported after 'EqualsValueClause' contexts");
return(false);
}
}
return(true);
}
public static ObjectCreationExpressionSyntax CreateObjectCreationExpression(
string objectName,
InitializerExpressionSyntax initializerExpression,
params ArgumentSyntax[] arguments)
{
var methodArgumentList = new SeparatedSyntaxList <ArgumentSyntax>().AddRange(arguments);
return(SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(objectName),
SyntaxFactory.ArgumentList(methodArgumentList),
initializerExpression));
}
private static ArrayCreationExpressionSyntax CreateArrayCreationExpression(
SyntaxGenerator syntaxGenerator,
ITypeSymbol typeSymbol,
InitializerExpressionSyntax initializerExpressionSyntax)
{
var arrayType = CreateArrayTypeNode(syntaxGenerator, typeSymbol);
var syntaxes = CreateSimpleLambdaExpressions(initializerExpressionSyntax);
var initializer = InitializerExpression(SyntaxKind.ArrayInitializerExpression, syntaxes);
return(ArrayCreationExpression(arrayType, initializer));
}
private bool isValidPasswordComplexity(SemanticModel model, InitializerExpressionSyntax syntax)
{
if (syntax == null || syntax.Expressions.Count == 0)
{
return(false);
}
//Accouting for the inline assignment expression
int minLength = 0;
bool requireSpecialCharacter = false;
bool requireNumber = false;
bool requireUpperChar = false;
bool requireLowerChar = false;
foreach (AssignmentExpressionSyntax expression in syntax.Expressions)
{
//Get the property value
var value = model.GetConstantValue(expression.Right);
//If we have a value, set them to the local var
if (value.HasValue)
{
switch (expression.Left.ToString())
{
case "RequiredLength":
minLength = (int)value.Value;
break;
case "RequireNonLetterOrDigit":
requireSpecialCharacter = (bool)value.Value;
break;
case "RequireDigit":
requireNumber = (bool)value.Value;
break;
case "RequireLowercase":
requireLowerChar = (bool)value.Value;
break;
case "RequireUppercase":
requireUpperChar = (bool)value.Value;
break;
default:
break;
}
}
}
return(!isValidPasswordComplexity(minLength, requireSpecialCharacter, requireNumber, requireUpperChar, requireLowerChar));
}
public static void WriteArrayInitializer(this InitializerExpressionSyntax initializer, OutputWriter writer,
TypeSyntax type = null)
{
bool first = true;
ArrayTypeSyntax arrayType = null;
ExpressionSyntax[] fullDimension = null;
var inferredDimensions = new Dictionary <int, int>();
ITypeSymbol aType = null;
IArrayTypeSymbol _aType = null;
CreateArray(initializer, writer, type, arrayType, _aType, first, inferredDimensions);
}
public new void AddChildren()
{
base.AddChildren();
Kind = Node.Kind();
_newKeyword = ((ObjectCreationExpressionSyntax)Node).NewKeyword;
_newKeywordIsChanged = false;
_type = ((ObjectCreationExpressionSyntax)Node).Type;
_typeIsChanged = false;
_argumentList = ((ObjectCreationExpressionSyntax)Node).ArgumentList;
_argumentListIsChanged = false;
_initializer = ((ObjectCreationExpressionSyntax)Node).Initializer;
_initializerIsChanged = false;
}
private bool IsDictionaryAddible(HybInstance obj, InitializerExpressionSyntax init)
{
if (init.Expressions.Count > 0 &&
(init.Expressions[0] is AssignmentExpressionSyntax ||
init.Expressions[0] is InitializerExpressionSyntax))
{
if (obj.GetSetIndexerMethod() != null)
{
return(true);
}
}
return(false);
}
private void LoadFrom(InitializerExpressionSyntax syntax)
{
if (syntax == null)
{
error = new Error(Diagnostics.SSIL108_FeatureNotSupported, this.OriginalNode,
"rank-initialized arrays");
return;
}
foreach (var s in syntax.Expressions)
{
Arguments.Add(RoslynToSharpnode.MapExpression(s));
}
}
public override SyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
{
if (NormalizeWhitespaceOnly &&
node.IsKind(SyntaxKind.ArrayInitializerExpression) &&
_checkingMethod != RegisterInstanceName)
{
var openBrace = node.OpenBraceToken.WithLeadingTrivia(SyntaxHelper.Whitespace(12));
node = node.WithOpenBraceToken(openBrace);
var closeBrace = node.CloseBraceToken.WithLeadingTrivia(SyntaxHelper.EndOfLineTrivia, SyntaxHelper.Whitespace(12));
node = node.WithCloseBraceToken(closeBrace);
}
return(base.VisitInitializerExpression(node !));
}
private static bool WriteArrayElements(InitializerExpressionSyntax initializer, OutputWriter writer,
Dictionary <int, int> inferred, int level, bool omitbraces = false, ITypeSymbol elementType = null)
{
level++;
if (!omitbraces)
{
writer.Write("[");
}
bool first = true;
if (!inferred.ContainsKey(level))
{
inferred.Add(level, initializer.Expressions.Count);
}
foreach (var iexpression in initializer.Expressions)
{
if (first)
{
first = false;
}
else
{
writer.Write(",");
}
if (iexpression is InitializerExpressionSyntax)
{
WriteArrayElements(iexpression as InitializerExpressionSyntax, writer, inferred, level, omitbraces);
}
else
{
if (elementType != null)
{
// var type = TypeProcessor.GetTypeInfo(iexpression);
//Need to do this like a binary i.e. compare all
WriteBinaryExpression.WriteIt(writer, default(SyntaxToken), null, iexpression);
// Core.Write(writer, iexpression);
}
else
{
Core.Write(writer, iexpression);
}
}
}
if (!omitbraces)
{
writer.Write("]");
}
return(first);
}
private void SetArraySizes(InitializerExpressionSyntax initializer, int rank)
{
for (var level = 0; level < rank; level++)
{
if (initializer is null)
{
return;
}
Literal.CreateGenerated(cx, this, level, cx.Compilation.GetSpecialType(SpecialType.System_Int32), initializer.Expressions.Count, Location);
initializer = initializer.Expressions.FirstOrDefault() as InitializerExpressionSyntax;
}
}
private static async Task <Document> ReplaceEmptyInitializationBlock(Document document,
InitializerExpressionSyntax objectInitializer, SemanticModel semanticModel,
IMappingMatcher mappingMatcher, CancellationToken cancellationToken)
{
var oldObjCreation = objectInitializer.FindContainer <ObjectCreationExpressionSyntax>();
var createdObjectType = ModelExtensions.GetTypeInfo(semanticModel, oldObjCreation).Type;
var syntaxGenerator = SyntaxGenerator.GetGenerator(document);
var mappingEngine = new MappingEngine(semanticModel, syntaxGenerator);
var mappingContext = new MappingContext(objectInitializer, semanticModel);
var newObjectCreation = await mappingEngine.AddInitializerWithMappingAsync(oldObjCreation, mappingMatcher, createdObjectType, mappingContext).ConfigureAwait(false);
return(await document.ReplaceNodes(oldObjCreation, newObjectCreation, cancellationToken).ConfigureAwait(false));
}
public ExpressionSyntax createAddObject(XP.FoxaddobjectclauseContext context)
{
InitializerExpressionSyntax init = null;
if (context._FieldsInits.Count > 0)
{
init = _syntaxFactory.InitializerExpression(
SyntaxKind.ObjectInitializerExpression,
SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken),
MakeSeparatedList <ExpressionSyntax>(context._FieldsInits),
SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken));
}
return(CreateObject(context.Type.Get <TypeSyntax>(), EmptyArgumentList(), init));
}
/// <summary>Called when the visitor visits a InitializerExpressionSyntax node.</summary>
public override SyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
{
using (Tab())
{
var r = base.VisitInitializerExpression(node) as InitializerExpressionSyntax;
if (r.IsKind(SyntaxKind.ObjectInitializerExpression))
{
var ex = r.Expressions.Select(x => x.WithoutTrivia().WithLeadingTrivia(Tabs.BrTabs())).ToArray();
r = r.WithExpressions(SeparatedList <ExpressionSyntax>(ex)).WithCloseBraceToken(Token(SyntaxKind.CloseBraceToken).WithLeadingTrivia(Tabs.BrTabs_Prev()));
}
return(r);
}
}
internal static SignatureHelpState?GetSignatureHelpState(
InitializerExpressionSyntax argumentList,
int position
)
{
return(CommonSignatureHelpUtilities.GetSignatureHelpState(
argumentList,
position,
s_getInitializerExpressionOpenToken,
s_getInitializerExpressionCloseToken,
s_getInitializerExpressionArgumentsWithSeparators,
s_getInitializerExpressionNames
));
}
public static async Task <Document> RefactorAsync(
Document document,
InitializerExpressionSyntax initializer,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
InitializerExpressionSyntax newInitializer = GetMultilineInitializer(initializer)
.WithFormatterAnnotation();
SyntaxNode newRoot = oldRoot.ReplaceNode(initializer, newInitializer);
return(document.WithSyntaxRoot(newRoot));
}
private ITypeSymbol GetBinderTypeSymbol(InitializerExpressionSyntax initializer)
{
var binderAssignment = initializer?.Expressions
.OfType <AssignmentExpressionSyntax>()
.SingleOrDefault(assignment => IsBinderProperty(assignment.Left));
if (binderAssignment == null ||
binderAssignment.Right.IsNullLiteral())
{
return(null);
}
return(semanticModel.GetTypeInfo(binderAssignment.Right).Type);
}
public override SyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
{
_output.TrivialWrite('[');
int count = 0;
foreach (var expr in node.Expressions)
{
Visit(expr);
count++;
if (count < node.Expressions.Count)
_output.TrivialWrite(", ");
}
_output.TrivialWrite(']');
return node;
}
public static Task <Document> FixListAsync(
Document document,
InitializerExpressionSyntax initializerExpression,
ListFixMode fixMode = ListFixMode.Fix,
CancellationToken cancellationToken = default)
{
return(FixListAsync(
document,
initializerExpression,
initializerExpression.OpenBraceToken,
initializerExpression.Expressions,
fixMode,
cancellationToken));
}
public override void VisitInitializerExpression(InitializerExpressionSyntax node)
{
base.VisitInitializerExpression(node);
//var binaryExpressions = node?.DescendantNodes()?.OfType<BinaryExpressionSyntax>();
//if (binaryExpressions != null && binaryExpressions.Any())
//{
// Count++;
// foreach (var binaryExpression in binaryExpressions)
// {
// var conditionComplexity = GetConditionComplexity(binaryExpression);
// Count += conditionComplexity;
// }
//}
}
private static async Task <Document> FormatInitializerOnMultipleLinesAsync(
Document document,
InitializerExpressionSyntax initializer,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
InitializerExpressionSyntax newInitializer = GetMultilineInitializer(initializer)
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(initializer, newInitializer);
return(document.WithSyntaxRoot(newRoot));
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
InitializerExpressionSyntax initializer = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <InitializerExpressionSyntax>();
if (initializer == null)
{
return;
}
if (initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) &&
initializer.Parent?.IsKind(SyntaxKind.CollectionInitializerExpression) == true)
{
initializer = (InitializerExpressionSyntax)initializer.Parent;
}
if (initializer.Expressions.Count > 0 &&
!initializer.IsKind(SyntaxKind.ComplexElementInitializerExpression) &&
initializer.Parent?.IsAnyKind(
SyntaxKind.ArrayCreationExpression,
SyntaxKind.ImplicitArrayCreationExpression,
SyntaxKind.ObjectCreationExpression,
SyntaxKind.CollectionInitializerExpression) == true)
{
if (initializer.IsSingleline(includeExteriorTrivia: false))
{
context.RegisterRefactoring(
"Format initializer on multiple lines",
cancellationToken => FormatInitializerOnMultipleLinesAsync(
context.Document,
initializer,
cancellationToken));
}
else if (initializer.Expressions.All(expression => expression.IsSingleline()))
{
context.RegisterRefactoring(
"Format initializer on a single line",
cancellationToken => FormatInitializerOnSingleLineAsync(
context.Document,
initializer,
cancellationToken));
}
}
ExpandInitializerRefactoring.Register(context, initializer);
}
private static void ReportForUnimplemented(CodeRefactoringContext context,
IEnumerable<IMethodSymbol> unimplemntedProperties,
SemanticModel semanticModel,
InitializerExpressionSyntax node,
TypeInfo typeSymbol)
{
var typesymbols = semanticModel.GetTypeSymbols(node, typeSymbol);
var symbols = typesymbols.Where(x => ImplementsSomethingFor(x.TypeSymbol, unimplemntedProperties))
.Distinct();
foreach (var symbol in symbols)
context.RegisterRefactoring(
new FillInitializerFrom(node, symbol.Name, semanticModel, context.Document));
context.RegisterRefactoring(
new FillInitializer(node, semanticModel, context.Document));
}
private static SyntaxNode RewriteInitializer(InitializerExpressionSyntax initializer)
{
var existingItems = new List<ExpressionSyntax>(initializer.Expressions);
var last = existingItems.Last();
existingItems.Remove(last);
existingItems.Add(last.WithoutTrailingTrivia());
var existingSeparators = initializer.Expressions.GetSeparators();
var newSeparators = new List<SyntaxToken>(existingSeparators);
newSeparators.Add(SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(last.GetTrailingTrivia()));
var newInitializerExpressions = SyntaxFactory.SeparatedList(
existingItems,
newSeparators);
var fixedInitializer = initializer.WithExpressions(newInitializerExpressions);
return fixedInitializer;
}
internal override SymbolInfo GetCollectionInitializerSymbolInfoWorker(InitializerExpressionSyntax collectionInitializer, ExpressionSyntax node, CancellationToken cancellationToken = default(CancellationToken))
{
var boundCollectionInitializer = GetLowerBoundNode(collectionInitializer) as BoundCollectionInitializerExpression;
if (boundCollectionInitializer != null)
{
var boundAdd = boundCollectionInitializer.Initializers[collectionInitializer.Expressions.IndexOf(node)];
return GetSymbolInfoForNode(SymbolInfoOptions.DefaultOptions, boundAdd, boundAdd, null, binderOpt: null);
}
return SymbolInfo.None;
}
/// <summary> /// Gets symbol information about the 'Add' method corresponding to an expression syntax <paramref name="node"/> within collection initializer. /// This is the worker function that is overridden in various derived kinds of Semantic Models. It can assume that /// CheckSyntaxNode has already been called and the <paramref name="node"/> is in the right place in the syntax tree. /// </summary> internal abstract SymbolInfo GetCollectionInitializerSymbolInfoWorker(InitializerExpressionSyntax collectionInitializer, ExpressionSyntax node, CancellationToken cancellationToken = default(CancellationToken));
public static ImplicitArrayCreationExpressionSyntax ImplicitArrayCreationExpression(InitializerExpressionSyntax initializer = null)
{
var result = new ImplicitArrayCreationExpressionSyntax();
result.Initializer = initializer;
return result;
}
public static InitializerExpressionSyntax InitializerExpression(IEnumerable<ExpressionSyntax> expressions = null)
{
var result = new InitializerExpressionSyntax();
if (expressions != null)
result.Expressions.AddRange(expressions);
return result;
}
private IEnumerable<ITypeSymbol> InferTypeInInitializerExpression(
InitializerExpressionSyntax initializerExpression,
ExpressionSyntax expressionOpt = null,
SyntaxToken? previousToken = null)
{
if (initializerExpression.IsParentKind(SyntaxKind.ImplicitArrayCreationExpression))
{
// First, try to infer the type that the array should be. If we can infer an
// appropriate array type, then use the element type of the array. Otherwise,
// look at the siblings of this expression and use their type instead.
var arrayTypes = this.InferTypes((ExpressionSyntax)initializerExpression.Parent);
var elementTypes = arrayTypes.OfType<IArrayTypeSymbol>().Select(a => a.ElementType).Where(e => !IsUnusableType(e));
if (elementTypes.Any())
{
return elementTypes;
}
// { foo(), |
if (previousToken.HasValue && previousToken.Value.CSharpKind() == SyntaxKind.CommaToken)
{
var sibling = initializerExpression.Expressions.FirstOrDefault(e => e.SpanStart < previousToken.Value.SpanStart);
if (sibling != null)
{
var types = GetTypes(sibling);
if (types.Any())
{
return types;
}
}
}
foreach (var sibling in initializerExpression.Expressions)
{
if (sibling != expressionOpt)
{
var types = GetTypes(sibling);
if (types.Any())
{
return types;
}
}
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.EqualsValueClause))
{
// = { Foo() }
var equalsValueClause = (EqualsValueClauseSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = InferTypeInEqualsValueClause(equalsValueClause);
if (types.Any(t => t is IArrayTypeSymbol))
{
return types.OfType<IArrayTypeSymbol>().Select(t => t.ElementType);
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.ArrayCreationExpression))
{
// new int[] { Foo() }
var arrayCreation = (ArrayCreationExpressionSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = GetTypes(arrayCreation);
if (types.Any(t => t is IArrayTypeSymbol))
{
return types.OfType<IArrayTypeSymbol>().Select(t => t.ElementType);
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.ObjectCreationExpression))
{
// new List<T> { Foo() }
var objectCreation = (ObjectCreationExpressionSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = GetTypes(objectCreation);
if (types.Any(t => t is INamedTypeSymbol))
{
return types.OfType<INamedTypeSymbol>().SelectMany(t =>
GetCollectionElementType(t, parameterIndex: 0, parameterCount: 1));
}
}
else if (
initializerExpression.IsParentKind(SyntaxKind.ComplexElementInitializerExpression) &&
initializerExpression.Parent.IsParentKind(SyntaxKind.ObjectCreationExpression))
{
// new Dictionary<K,V> { { Foo(), ... } }
var objectCreation = (ObjectCreationExpressionSyntax)initializerExpression.Parent.Parent;
IEnumerable<ITypeSymbol> types = GetTypes(objectCreation);
if (types.Any(t => t is INamedTypeSymbol))
{
var parameterIndex = previousToken.HasValue
? initializerExpression.Expressions.GetWithSeparators().IndexOf(previousToken.Value) + 1
: initializerExpression.Expressions.IndexOf(expressionOpt);
return types.OfType<INamedTypeSymbol>().SelectMany(t =>
GetCollectionElementType(t,
parameterIndex: parameterIndex,
parameterCount: initializerExpression.Expressions.Count));
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.SimpleAssignmentExpression))
{
// new Foo { a = { Foo() } }
var assignExpression = (BinaryExpressionSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = GetTypes(assignExpression.Left);
if (types.Any(t => t is INamedTypeSymbol))
{
var parameterIndex = previousToken.HasValue
? initializerExpression.Expressions.GetWithSeparators().IndexOf(previousToken.Value) + 1
: initializerExpression.Expressions.IndexOf(expressionOpt);
return types.OfType<INamedTypeSymbol>().SelectMany(t =>
GetCollectionElementType(t,
parameterIndex: parameterIndex,
parameterCount: initializerExpression.Expressions.Count));
}
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public FillInitializerFrom(InitializerExpressionSyntax node, string sourcename, SemanticModel semanticModel, Document document)
{
this.node = node;
this.sourcename = sourcename;
this.semanticModel = semanticModel;
this.document = document;
Title = $"Fill from {sourcename}";
}
private IEnumerable<ITypeSymbol> InferTypeInInitializerExpression(
InitializerExpressionSyntax initializerExpression,
ExpressionSyntax expressionOpt = null,
SyntaxToken? previousToken = null)
{
if (initializerExpression.IsKind(SyntaxKind.ComplexElementInitializerExpression))
{
// new Dictionary<K,V> { { x, ... } }
// new C { Prop = { { x, ... } } }
var parameterIndex = previousToken.HasValue
? initializerExpression.Expressions.GetSeparators().ToList().IndexOf(previousToken.Value) + 1
: initializerExpression.Expressions.IndexOf(expressionOpt);
var addMethodSymbols = SemanticModel.GetCollectionInitializerSymbolInfo(initializerExpression).GetAllSymbols();
var addMethodParameterTypes = addMethodSymbols
.Cast<IMethodSymbol>()
.Where(a => a.Parameters.Length == initializerExpression.Expressions.Count)
.Select(a => a.Parameters.ElementAtOrDefault(parameterIndex)?.Type)
.WhereNotNull();
if (addMethodParameterTypes.Any())
{
return addMethodParameterTypes;
}
}
else if (initializerExpression.IsKind(SyntaxKind.CollectionInitializerExpression))
{
if (expressionOpt != null)
{
// new List<T> { x, ... }
// new C { Prop = { x, ... } }
var addMethodSymbols = SemanticModel.GetCollectionInitializerSymbolInfo(expressionOpt).GetAllSymbols();
var addMethodParameterTypes = addMethodSymbols
.Cast<IMethodSymbol>()
.Where(a => a.Parameters.Length == 1)
.Select(a => a.Parameters[0].Type).WhereNotNull();
if (addMethodParameterTypes.Any())
{
return addMethodParameterTypes;
}
}
else
{
// new List<T> { x,
// new C { Prop = { x,
foreach (var sibling in initializerExpression.Expressions.Where(e => e.Kind() != SyntaxKind.ComplexElementInitializerExpression))
{
var types = GetTypes(sibling);
if (types.Any())
{
return types;
}
}
}
}
if (initializerExpression.IsParentKind(SyntaxKind.ImplicitArrayCreationExpression))
{
// new[] { 1, x }
// First, try to infer the type that the array should be. If we can infer an
// appropriate array type, then use the element type of the array. Otherwise,
// look at the siblings of this expression and use their type instead.
var arrayTypes = this.InferTypes((ExpressionSyntax)initializerExpression.Parent);
var elementTypes = arrayTypes.OfType<IArrayTypeSymbol>().Select(a => a.ElementType).Where(IsUsableTypeFunc);
if (elementTypes.Any())
{
return elementTypes;
}
foreach (var sibling in initializerExpression.Expressions)
{
if (sibling != expressionOpt)
{
var types = GetTypes(sibling);
if (types.Any())
{
return types;
}
}
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.EqualsValueClause))
{
// = { Foo() }
var equalsValueClause = (EqualsValueClauseSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = InferTypeInEqualsValueClause(equalsValueClause);
if (types.Any(t => t is IArrayTypeSymbol))
{
return types.OfType<IArrayTypeSymbol>().Select(t => t.ElementType);
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.ArrayCreationExpression))
{
// new int[] { Foo() }
var arrayCreation = (ArrayCreationExpressionSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = GetTypes(arrayCreation);
if (types.Any(t => t is IArrayTypeSymbol))
{
return types.OfType<IArrayTypeSymbol>().Select(t => t.ElementType);
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.ObjectCreationExpression))
{
// new List<T> { Foo() }
var objectCreation = (ObjectCreationExpressionSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = GetTypes(objectCreation);
if (types.Any(t => t is INamedTypeSymbol))
{
return types.OfType<INamedTypeSymbol>().SelectMany(t =>
GetCollectionElementType(t, parameterIndex: 0));
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.SimpleAssignmentExpression))
{
// new Foo { a = { Foo() } }
if (expressionOpt != null)
{
var addMethodSymbols = SemanticModel.GetCollectionInitializerSymbolInfo(expressionOpt).GetAllSymbols();
var addMethodParameterTypes = addMethodSymbols.Select(a => ((IMethodSymbol)a).Parameters[0].Type).WhereNotNull();
if (addMethodParameterTypes.Any())
{
return addMethodParameterTypes;
}
}
var assignExpression = (AssignmentExpressionSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> types = GetTypes(assignExpression.Left);
if (types.Any(t => t is INamedTypeSymbol))
{
// new Foo { a = { Foo() } }
var parameterIndex = previousToken.HasValue
? initializerExpression.Expressions.GetSeparators().ToList().IndexOf(previousToken.Value) + 1
: initializerExpression.Expressions.IndexOf(expressionOpt);
return types.OfType<INamedTypeSymbol>().SelectMany(t =>
GetCollectionElementType(t, 0));
}
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public InitializerExpressionTranslation(InitializerExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Expressions = syntax.Expressions.Get<ExpressionSyntax, ExpressionTranslation>(this);
}
public static ObjectCreationExpressionSyntax ObjectCreationExpression(string type = null, ArgumentListSyntax argumentList = null, InitializerExpressionSyntax initializer = null)
{
var result = new ObjectCreationExpressionSyntax();
if (type != null)
result.Type = ParseName(type);
result.ArgumentList = argumentList;
result.Initializer = initializer;
return result;
}
private bool TryGenerateArrayLiteral(InitializerExpressionSyntax initializerExpression)
{
using (LiteralTag())
using (ArrayTag())
{
foreach (var expression in initializerExpression.Expressions)
{
if (!TryGenerateExpression(expression))
{
return false;
}
}
}
return true;
}
public virtual void VisitInitializerExpression(InitializerExpressionSyntax node)
{
DefaultVisit(node);
}
private static IEnumerable<IMethodSymbol> GetUnimplemntedProperties(InitializerExpressionSyntax expression, IEnumerable<IMethodSymbol> properties)
{
var uniimplemntedProperties =
properties.Where(
x =>
expression.Expressions.All(
y => ((IdentifierNameSyntax)((AssignmentExpressionSyntax)y).Left).Identifier.Text != x.PropertyName()));
return uniimplemntedProperties;
}
private static IEnumerable<IMethodSymbol> GetMissingProperties(InitializerExpressionSyntax expression, ITypeSymbol typeSymbol)
{
var properties =
typeSymbol.GetBaseTypesAndThis().SelectMany(x => x.GetMembers()).Where(x => x.Kind == SymbolKind.Method).Cast<IMethodSymbol>().Where(
x => x.MethodKind == MethodKind.PropertySet);
var missingprops = GetUnimplemntedProperties(expression, properties);
return missingprops;
}
private static SyntaxNode ImplementAllSettersFromExpression(InitializerExpressionSyntax expression,
string sourcename,
ITypeSymbol targetTypeInfo,
ITypeSymbol sourceType)
{
var missingprops = GetMissingProperties(expression, targetTypeInfo);
var newproperties =
sourceType.GetBaseTypesAndThis().SelectMany(x => x.GetMembers()).Where(x => x.Kind == SymbolKind.Property).Cast<IPropertySymbol>().Where(x => x.IsMissing(missingprops));
var newExpression = expression.AddExpressions(
newproperties.Select(x =>
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(x.Name),
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(sourcename),
SyntaxFactory.IdentifierName(x.Name))))
.Cast<ExpressionSyntax>().ToArray());
return newExpression;
}
public override void VisitInitializerExpression(InitializerExpressionSyntax node)
{
base.VisitInitializerExpression(node);
}
private IEnumerable<ITypeSymbol> InferTypeInInitializerExpression(
InitializerExpressionSyntax initializerExpression,
ExpressionSyntax expressionOpt = null,
SyntaxToken? previousToken = null)
{
if (initializerExpression.IsParentKind(SyntaxKind.ImplicitArrayCreationExpression))
{
// First, try to infer the type that the array should be. If we can infer an
// appropriate array type, then use the element type of the array. Otherwise,
// look at the siblings of this expression and use their type instead.
var arrayTypes = this.InferTypes((ExpressionSyntax)initializerExpression.Parent);
var elementTypes = arrayTypes.OfType<IArrayTypeSymbol>().Select(a => a.ElementType).Where(e => !IsUnusableType(e));
if (elementTypes.Any())
{
return elementTypes;
}
// { foo(), |
if (previousToken.HasValue && previousToken.Value.CSharpKind() == SyntaxKind.CommaToken)
{
var sibling = initializerExpression.Expressions.FirstOrDefault(e => e.SpanStart < previousToken.Value.SpanStart);
if (sibling != null)
{
var types = GetTypes(sibling);
if (types.Any())
{
return types;
}
}
}
foreach (var sibling in initializerExpression.Expressions)
{
if (sibling != expressionOpt)
{
var types = GetTypes(sibling);
if (types.Any())
{
return types;
}
}
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.ArrayCreationExpression))
{
// new int[] { Foo() }
var arrayCreation = (ArrayCreationExpressionSyntax)initializerExpression.Parent;
IEnumerable<ITypeSymbol> type = GetTypes(arrayCreation);
// BUG: (vladres) Is it a correct type check?
// BUG: Is there a type that implements both IEnumerable<ITypeSymbol> and IArrayTypeSymbol?
// BUG: Or it was intended to be:
// BUG: type.FirstOrDefault() as IArrayTypeSymbol
// BUG: or
// BUG: type.OfType<IArrayTypeSymbol>().FirstOrDefault() ?
// BUG: (see other similar problems below)
if (type is IArrayTypeSymbol)
{
return SpecializedCollections.SingletonEnumerable(((IArrayTypeSymbol)type).ElementType);
}
}
else if (initializerExpression.IsParentKind(SyntaxKind.ObjectCreationExpression))
{
// new List<T> { Foo() }
var objectCreation = (ObjectCreationExpressionSyntax)initializerExpression.Parent;
// BUG: (vladres) Is it a correct type check?
// BUG: Is there a type that implements both IEnumerable<ITypeSymbol> and INamedTypeSymbol?
// BUG: (see other similar problems below)
var type = GetTypes(objectCreation) as INamedTypeSymbol;
return GetCollectionElementType(type, parameterIndex: 0, parameterCount: 1);
}
else if (
initializerExpression.IsParentKind(SyntaxKind.ComplexElementInitializerExpression) &&
initializerExpression.Parent.IsParentKind(SyntaxKind.ObjectCreationExpression))
{
// new Dictionary<K,V> { { Foo(), ... } }
var objectCreation = (ObjectCreationExpressionSyntax)initializerExpression.Parent.Parent;
// BUG: (vladres) Is it a correct type check?
// BUG: Is there a type that implements both IEnumerable<ITypeSymbol> and INamedTypeSymbol?
// BUG: (see other similar problems below)
var type = GetTypes(objectCreation) as INamedTypeSymbol;
var parameterIndex = previousToken.HasValue
? initializerExpression.Expressions.GetWithSeparators().IndexOf(previousToken.Value) + 1
: initializerExpression.Expressions.IndexOf(expressionOpt);
return GetCollectionElementType(type,
parameterIndex: parameterIndex,
parameterCount: initializerExpression.Expressions.Count);
}
else if (initializerExpression.IsParentKind(SyntaxKind.SimpleAssignmentExpression))
{
// new Foo { a = { Foo() } }
var assignExpression = (BinaryExpressionSyntax)initializerExpression.Parent;
// BUG: (vladres) Is it a correct type check?
// BUG: Is there a type that implements both IEnumerable<ITypeSymbol> and INamedTypeSymbol?
var type = GetTypes(assignExpression.Left) as INamedTypeSymbol;
var parameterIndex = previousToken.HasValue
? initializerExpression.Expressions.GetWithSeparators().IndexOf(previousToken.Value) + 1
: initializerExpression.Expressions.IndexOf(expressionOpt);
return GetCollectionElementType(type,
parameterIndex: parameterIndex,
parameterCount: initializerExpression.Expressions.Count);
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public static ImplicitArrayCreationExpressionSyntax ImplicitArrayCreationExpression(int? commas = default(int?), InitializerExpressionSyntax initializer = null)
{
var result = new ImplicitArrayCreationExpressionSyntax();
result.Commas = commas;
result.Initializer = initializer;
return result;
}
public static ObjectCreationExpressionSyntax ObjectCreationExpression(TypeSyntax type = null, ArgumentListSyntax argumentList = null, InitializerExpressionSyntax initializer = null)
{
var result = new ObjectCreationExpressionSyntax();
result.Type = type;
result.ArgumentList = argumentList;
result.Initializer = initializer;
return result;
}
public FillInitializer(InitializerExpressionSyntax node, SemanticModel semanticModel, Document document)
{
this.node = node;
this.semanticModel = semanticModel;
this.document = document;
Title = $"Fill in blanks";
}
public static ArrayCreationExpressionSyntax ArrayCreationExpression(ArrayTypeSyntax type = null, InitializerExpressionSyntax initializer = null)
{
var result = new ArrayCreationExpressionSyntax();
result.Type = type;
result.Initializer = initializer;
return result;
}
internal override SymbolInfo GetCollectionInitializerSymbolInfoWorker(InitializerExpressionSyntax collectionInitializer, ExpressionSyntax node, CancellationToken cancellationToken = default(CancellationToken))
{
var model = this.GetMemberModel(collectionInitializer);
if (model != null)
{
// Expression occurs in an executable code (method body or initializer) context. Use that
// model to get the information.
return model.GetCollectionInitializerSymbolInfoWorker(collectionInitializer, node, cancellationToken);
}
return SymbolInfo.None;
}
public static InitializerExpressionSyntax InitializerExpression(params ExpressionSyntax[] expressions)
{
var result = new InitializerExpressionSyntax();
if (expressions != null)
result.Expressions.AddRange(expressions);
return result;
}
public static ArrayCreationExpressionSyntax ArrayCreationExpression(string type = null, InitializerExpressionSyntax initializer = null)
{
var result = new ArrayCreationExpressionSyntax();
if (type != null)
result.Type = (ArrayTypeSyntax)ParseName(type);
result.Initializer = initializer;
return result;
}
public override void VisitInitializerExpression(InitializerExpressionSyntax node)
{
base.VisitInitializerExpression(node);
_counter += node.Expressions.Count;
}
