public ResolveArrayArgument(ExcessContext ctx, SyntaxNode node, ArrayCreationExpressionSyntax arg)
{
ctx_ = ctx;
node_ = node;
args_.Add(SyntaxFactory.Argument(arg));
}
public virtual void Visit(ArrayCreationExpressionSyntax arrayCreationExpressionSyntax)
{
Visit(arrayCreationExpressionSyntax.Type);
foreach (var expressionSyntax in arrayCreationExpressionSyntax.Parameter)
{
Visit(expressionSyntax);
}
}
private IEnumerable<TypeInferenceInfo> InferTypeInArrayCreationExpression(
ArrayCreationExpressionSyntax arrayCreationExpression, SyntaxToken? previousToken = null)
{
if (previousToken.HasValue && previousToken.Value != arrayCreationExpression.NewKeyword)
{
// Has to follow the 'new' keyword.
return SpecializedCollections.EmptyEnumerable<TypeInferenceInfo>();
}
if (previousToken.HasValue && previousToken.Value.GetPreviousToken().Kind() == SyntaxKind.EqualsToken)
{
// We parsed an array creation but the token before `new` is `=`.
// This could be a case like:
//
// int[] array;
// Program p = new |
// array[4] = 4;
//
// This is similar to the cases described in `InferTypeInObjectCreationExpression`.
// Again, all we have to do is back up to before `new`.
return InferTypes(previousToken.Value.SpanStart);
}
var outerTypes = InferTypes(arrayCreationExpression);
return outerTypes.Where(o => o.InferredType is IArrayTypeSymbol);
}
public ArrayCreationSharpnode(ArrayCreationExpressionSyntax syntax) : base(syntax)
{
this.LoadFrom(syntax.Initializer);
}
private static void ReportRedundantArraySizeSpecifier(SyntaxNodeAnalysisContext context, ArrayCreationExpressionSyntax array)
{
if (array.Initializer == null ||
array.Type == null)
{
return;
}
var rankSpecifier = array.Type.RankSpecifiers.FirstOrDefault();
if (rankSpecifier == null ||
rankSpecifier.Sizes.Any(s => s.IsKind(SyntaxKind.OmittedArraySizeExpression)))
{
return;
}
foreach (var size in rankSpecifier.Sizes)
{
context.ReportDiagnostic(Diagnostic.Create(Rule, size.GetLocation(),
ImmutableDictionary <string, string> .Empty.Add(DiagnosticTypeKey, RedundancyType.ArraySize.ToString()),
"array size specification"));
}
}
public static void Go(OutputWriter writer, ArrayCreationExpressionSyntax array)
{
//TODO: does this info just get discarded ?
// if (array.Type.RankSpecifiers.Count > 1 || array.Type.RankSpecifiers.Single().Sizes.Count > 1)
// throw new Exception("Multi-dimensional arrays are not supported " + Utility.Descriptor(array));
// var rankExpression = array.Type.RankSpecifiers.FirstOrDefault().Sizes.Single();
// IEnumerable<ExpressionSyntax> fullDimension =
// array.Type.RankSpecifiers.Select(o => o.Sizes).SelectMany(j=>j);
if (array.Initializer != null)
{
var aType = TypeProcessor.GetTypeInfo(array).Type as IArrayTypeSymbol;
// writer.Write("new ");
// writer.Write(TypeProcessor.ConvertType(array.Type.ElementType));
// writer.Write("[]{");
// var statement = " new (smGC) ";
// writer.Write(" new ");
var type = "";
if (aType.Rank == 1) // Jagged
{
var rCount = array.Type.RankSpecifiers.Count;
for (int i = 0; i < rCount; i++)
{
type += ("Array_T!(");
var typeInfo = TypeProcessor.GetTypeInfo(array.Type.ElementType);
if ((i + 1) == rCount)
{
var isPtr = typeInfo.Type != null && typeInfo.Type.IsValueType; // ? "" : "";
var typeString = TypeProcessor.ConvertType(typeInfo.Type) + " ";
// Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
//writer.Write(typeString);
type += typeString;
}
}
for (int i = 0; i < rCount; i++)
{
if ((i > 0) && rCount > 1)
{
type = type;
}
type += (")");
}
}
else
{
type += "Array_T!(" + TypeProcessor.ConvertType(array.Type.ElementType)
/* + Enumerable.Range (0, aType.Rank-1).Select (l => "[]").Aggregate ((a, b) => a + b).ToString () */ +
")";
// var typeInfo = TypeProcessor.GetTypeInfo (array.Type.ElementType);
}
// if (type.ConvertedType.TypeKind == Microsoft.CodeAnalysis.TypeKind.TypeParameter)
// writer.Write (" __TypeNew!(" + type + ")([");
// else
//{
writer.Write("new " + type);
writer.Write("(");
//}
bool first = true;
array.Initializer.WriteArrayInitializer(writer, array.Type);
writer.Write(")");
}
else
{
// int.TryParse(rankExpression != null ? rankExpression.ToString() : "0", out sizeInteger);
// writer.Write(" new ");
var typeStr = "";
var rCount = array.Type.RankSpecifiers.Count;
for (int i = 0; i < rCount; i++)
{
typeStr += ("Array_T!(");
var type = TypeProcessor.GetTypeInfo(array.Type.ElementType);
if ((i + 1) == rCount)
{
// if (type.Type != null && (type.Type.IsValueType == false))
// typeStr += ("");
// Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
typeStr += (TypeProcessor.ConvertType(array.Type.ElementType));
}
}
for (int i = 0; i < rCount; i++)
{
// if ((i > 0) && rCount > 1)
// typeStr+=("");
typeStr += (")");
}
writer.Write("new " + typeStr);
writer.Write("(");
array.Initializer.WriteArrayInitializer(writer, array.Type);
writer.Write(")");
// writer.Write("new Array_T!(");
//
//
//
// var symbol =Program.GetModel(array).GetDeclaredSymbol(array.Type.ElementType);
//
// var lsymbol = symbol as ILocalSymbol;
//
// if (lsymbol != null && (lsymbol.Type.IsValueType == false))
// writer.Write(""); // Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
//
// writer.Write(TypeProcessor.ConvertType(array.Type.ElementType));
// writer.Write(">("+fullDimension+")");
// Core.Write(writer, array.Type.RankSpecifiers.Single().Sizes.Single());
// writer.Write(")");
// if (array.Initializer != null)
// throw new Exception("Initalizers along with array sizes are not supported - please use a size or an initializer " + Utility.Descriptor(array));
// writer.Write("new ");
// writer.Write(TypeProcessor.ConvertType(array.Type.ElementType));
// writer.Write("[]{");
// Core.Write(writer, array.Type.RankSpecifiers.Single().Sizes.Single());
// writer.Write("}");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="InvokationExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
public ArrayCreationExpression(ArrayCreationExpressionSyntax syntaxNode)
: this(syntaxNode, null)
{
}
public ArrayCreationExpressionTranslation(ArrayCreationExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Type = syntax.Type.Get<ArrayTypeTranslation>(this);
Initializer = syntax.Initializer.Get<InitializerExpressionTranslation>(this);
}
public ArrayCreationExpressionTranslation(ArrayCreationExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Type = syntax.Type.Get <ArrayTypeTranslation>(this);
Initializer = syntax.Initializer.Get <InitializerExpressionTranslation>(this);
}
public override SyntaxNode VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
node = (ArrayCreationExpressionSyntax)base.VisitArrayCreationExpression(node);
Classes.Add(node);
return(node);
}
public ArrayCreationStatementInterpreter(StatementInterpreterHandler statementInterpreterHandler, ArrayCreationExpressionSyntax arrayCreationExpressionSyntax, Microsoft.CodeAnalysis.SemanticModel semanticModel)
{
this.statementInterpreterHandler = statementInterpreterHandler;
this.arrayCreationExpressionSyntax = arrayCreationExpressionSyntax;
this.semanticModel = semanticModel;
}
// new数组表达式
public virtual void VisitArrayCreationExpressionSyntax(ArrayCreationExpressionSyntax value)
{
DefaultVisit(value);
}
public static void Go(OutputWriter writer, ArrayCreationExpressionSyntax array)
{
//TODO: does this info just get discarded ?
// if (array.Type.RankSpecifiers.Count > 1 || array.Type.RankSpecifiers.Single().Sizes.Count > 1)
// throw new Exception("Multi-dimensional arrays are not supported " + Utility.Descriptor(array));
// var rankExpression = array.Type.RankSpecifiers.FirstOrDefault().Sizes.Single();
// IEnumerable<ExpressionSyntax> fullDimension =
// array.Type.RankSpecifiers.Select(o => o.Sizes).SelectMany(j=>j);
if (array.Initializer != null)
{
var aType = TypeProcessor.GetTypeInfo(array).Type as IArrayTypeSymbol;
// writer.Write("new ");
// writer.Write(TypeProcessor.ConvertType(array.Type.ElementType));
// writer.Write("[]{");
// var statement = " new (smGC) ";
// writer.Write(" new ");
var type = "";
if (aType.Rank == 1) // Jagged
{
var rCount = array.Type.RankSpecifiers.Count;
for (int i = 0; i < rCount; i++)
{
type += ("Array_T!(");
var typeInfo = TypeProcessor.GetTypeInfo(array.Type.ElementType);
if ((i + 1) == rCount)
{
var isPtr = typeInfo.Type != null && typeInfo.Type.IsValueType; // ? "" : "";
var typeString = TypeProcessor.ConvertType(typeInfo.Type) + " ";
// Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
//writer.Write(typeString);
type += typeString;
}
}
for (int i = 0; i < rCount; i++)
{
if ((i > 0) && rCount > 1)
type = type;
type += (")");
}
}
else
{
type += "Array_T!(" + TypeProcessor.ConvertType(array.Type.ElementType)
/* + Enumerable.Range (0, aType.Rank-1).Select (l => "[]").Aggregate ((a, b) => a + b).ToString () */ +
")";
// var typeInfo = TypeProcessor.GetTypeInfo (array.Type.ElementType);
}
// if (type.ConvertedType.TypeKind == Microsoft.CodeAnalysis.TypeKind.TypeParameter)
// writer.Write (" __TypeNew!(" + type + ")([");
// else
//{
writer.Write("new " + type);
writer.Write("(");
//}
bool first = true;
array.Initializer.WriteArrayInitializer(writer, array.Type);
writer.Write(")");
}
else
{
// int.TryParse(rankExpression != null ? rankExpression.ToString() : "0", out sizeInteger);
// writer.Write(" new ");
var typeStr = "";
var rCount = array.Type.RankSpecifiers.Count;
for (int i = 0; i < rCount; i++)
{
typeStr += ("Array_T!(");
var type = TypeProcessor.GetTypeInfo(array.Type.ElementType);
if ((i + 1) == rCount)
{
// if (type.Type != null && (type.Type.IsValueType == false))
// typeStr += ("");
// Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
typeStr += (TypeProcessor.ConvertType(array.Type.ElementType));
}
}
for (int i = 0; i < rCount; i++)
{
// if ((i > 0) && rCount > 1)
// typeStr+=("");
typeStr += (")");
}
writer.Write("new " + typeStr);
writer.Write("(");
array.Initializer.WriteArrayInitializer(writer, array.Type);
writer.Write(")");
// writer.Write("new Array_T!(");
//
//
//
// var symbol =Program.GetModel(array).GetDeclaredSymbol(array.Type.ElementType);
//
// var lsymbol = symbol as ILocalSymbol;
//
// if (lsymbol != null && (lsymbol.Type.IsValueType == false))
// writer.Write(""); // Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
//
// writer.Write(TypeProcessor.ConvertType(array.Type.ElementType));
// writer.Write(">("+fullDimension+")");
// Core.Write(writer, array.Type.RankSpecifiers.Single().Sizes.Single());
// writer.Write(")");
// if (array.Initializer != null)
// throw new Exception("Initalizers along with array sizes are not supported - please use a size or an initializer " + Utility.Descriptor(array));
// writer.Write("new ");
// writer.Write(TypeProcessor.ConvertType(array.Type.ElementType));
// writer.Write("[]{");
// Core.Write(writer, array.Type.RankSpecifiers.Single().Sizes.Single());
// writer.Write("}");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="InvokationExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
/// <param name="semanticModel"></param>
public ArrayCreationExpression(ArrayCreationExpressionSyntax syntaxNode, SemanticModel semanticModel)
: base(syntaxNode, semanticModel)
{
}
private static bool AtLeastOneExactTypeMatch(SemanticModel semanticModel, ArrayCreationExpressionSyntax arrayCreation, IArrayTypeSymbol arrayType)
{
return arrayCreation.Initializer.Initializers.Any(initializer => arrayType.ElementType.Equals(semanticModel.GetTypeInfo(initializer).Type));
}
public virtual void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node) => DefaultVisit(node);
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitArrayCreationExpression(node);
}
private static bool AtLeastOneExactTypeMatch(SemanticModel semanticModel, ArrayCreationExpressionSyntax arrayCreation, IArrayTypeSymbol arrayType)
{
return(arrayCreation.Initializer.Initializers.Any(initializer => arrayType.ElementType.Equals(semanticModel.GetTypeInfo(initializer).Type)));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitArrayCreationExpression(node);
}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
base.VisitArrayCreationExpression(node);
}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax newArrayExpression)
{
Visit(newArrayExpression.Type);
Visit(newArrayExpression.Initializer);
}
/// <inheritdoc />
public override Expression VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
return(base.VisitArrayCreationExpression(node));
}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
IsComplex = true;
base.VisitArrayCreationExpression(node);
}
private bool CanBeReplaceWithEnumerableEmpty(ArrayCreationExpressionSyntax arrayCreation)
{
return(IsInitializationBlockEmpty(arrayCreation.Initializer));
}
public FlatOperand Resolve(ArrayCreationExpressionSyntax node, TypeInfo result_type, FlatOperand into_lvalue, List<FlatStatement> instructions)
{
/* // Summary:
// InitializerExpressionSyntax node representing the initializer of the array
// creation expression.
public InitializerExpressionSyntax Initializer { get; }
//
// Summary:
// SyntaxToken representing the new keyword.
public SyntaxToken NewKeyword { get; }
//
// Summary:
// ArrayTypeSyntax node representing the type of the array.
public ArrayTypeSyntax Type { get; }
*/
if (node.Initializer != null)
{
throw new NotImplementedException("new array with initializer");
}
/*
// Summary:
// TypeSyntax node representing the type of the element of the array.
public TypeSyntax ElementType { get; }
//
// Summary:
// SyntaxList of ArrayRankSpecifierSyntax nodes representing the list of rank
// specifiers for the array.
public SyntaxList<ArrayRankSpecifierSyntax> RankSpecifiers { get; }
/**/
/*
if (node.Type.RankSpecifiers.Count > 1)
{
throw new NotImplementedException("new array with multiple rank specifiers");
}
/*
public int Rank { get; }
public SeparatedSyntaxList<ExpressionSyntax> Sizes { get; }
*/
// get total number of elements
FlatOperand fop_total = null;
foreach(ArrayRankSpecifierSyntax arss in node.Type.RankSpecifiers)
{
foreach(ExpressionSyntax es in arss.Sizes)
{
if (fop_total != null)
{
FlatOperand fop_size = ResolveExpression(es, null, instructions);
FlatOperand fop_total_lvalue = AllocateRegister("");
FlatStatement.MUL(fop_total_lvalue, fop_total, fop_size);
fop_total = fop_total_lvalue.AsRValue(FlatValue.Int32(0));
}
else
{
fop_total = ResolveExpression(es, null, instructions);
}
}
}
TypeInfo ti = Model.GetTypeInfo(node.Type.ElementType);
FlatOperand fop_type = Resolve(ti.ConvertedType, null, instructions);
if (into_lvalue == null)
{
FlatOperand register_fop = AllocateRegister("");
into_lvalue = register_fop.GetLValue(this, instructions);
}
instructions.Add(FlatStatement.NEWARRAY(into_lvalue, fop_total, fop_type));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
private static void ReportRedundantArrayTypeSpecifier(SyntaxNodeAnalysisContext context, ArrayCreationExpressionSyntax array)
{
if (array.Initializer == null ||
!array.Initializer.Expressions.Any() ||
array.Type == null)
{
return;
}
var rankSpecifier = array.Type.RankSpecifiers.FirstOrDefault();
if (rankSpecifier == null ||
rankSpecifier.Sizes.Any(s => !s.IsKind(SyntaxKind.OmittedArraySizeExpression)))
{
return;
}
var arrayType = context.SemanticModel.GetTypeInfo(array.Type).Type as IArrayTypeSymbol;
if (arrayType == null)
{
return;
}
var canBeSimplified = array.Initializer.Expressions
.Select(exp => context.SemanticModel.GetTypeInfo(exp).Type)
.All(type => object.Equals(type, arrayType.ElementType));
if (canBeSimplified)
{
var location = Location.Create(array.SyntaxTree, TextSpan.FromBounds(
array.Type.ElementType.SpanStart, array.Type.RankSpecifiers.Last().SpanStart));
context.ReportDiagnostic(Diagnostic.Create(Rule, location,
ImmutableDictionary <string, string> .Empty.Add(DiagnosticTypeKey, RedundancyType.ArrayType.ToString()),
"array type"));
}
}
public void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
ExpressionStart(node);
if (_writer.Configuration.Other.AlignMultiLineConstructs.ArrayObjectCollectionInitializer)
_writer.SetAlignmentBreak(true);
_writer.WriteKeyword(PrinterKeyword.New);
_writer.WriteSpace();
node.Type.Accept(this);
if (node.Initializer != null)
{
_writer.PushBraceFormatting(_writer.Configuration.BracesLayout.ArrayAndObjectInitializer, false);
node.Initializer.Accept(this);
_writer.PopBraceFormatting();
}
if (_writer.Configuration.Other.AlignMultiLineConstructs.ArrayObjectCollectionInitializer)
_writer.SetAlignmentBreak(false);
ExpressionEnd(node);
}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
throw new NotImplementedException();
}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
Emit <ArrayCreationExpressionBlock, ArrayCreationExpressionSyntax>(node);
}
public override SyntaxNode VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
_output.TrivialWrite('[');
foreach (var rs in node.Type.RankSpecifiers)
this.Visit(rs);
int count = 0;
if (node.Initializer != null)
{
foreach (var expr in node.Initializer.Expressions)
{
this.VisitExpression(expr);
count++;
if (count != node.Initializer.Expressions.Count)
_output.TrivialWrite(", ");
}
}
_output.TrivialWrite(']');
return node;
}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node) => base.VisitArrayCreationExpression(node);
private static bool AllTypesAreConvertible(SemanticModel semanticModel, ArrayCreationExpressionSyntax arrayCreation, IArrayTypeSymbol arrayType)
{
return arrayCreation.Initializer.Initializers.All(initializer =>
{
var conversion = semanticModel.ClassifyConversion(initializer, arrayType.ElementType);
return conversion.Exists && (conversion.IsIdentity || conversion.IsWidening);
});
}
private IEnumerable <string> Visit(ArrayCreationExpressionSyntax node)
{
return(node.Initializer.Expressions.Select(Visit).Where(v => v != null).SelectMany(v => v));
}
public static string ArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
var output = "[ ";
output += string.Join(", ", node.Initializer.Expressions.Select(SyntaxNode));
return output + " ]";
}
private static bool CanBeReplaceWithEnumerableEmpty(ArrayCreationExpressionSyntax arrayCreation) => IsInitializationBlockEmpty(arrayCreation.Initializer);
private static void AnalyzeRankSpecifiers(SyntaxNodeAnalysisContext context, ArrayCreationExpressionSyntax arrayCreation)
{
if (!arrayCreation.Type.RankSpecifiers.Any())
{
return;
}
foreach (var arrayRankSpecifierSyntax in arrayCreation.Type.RankSpecifiers)
{
var openBracketToken = arrayRankSpecifierSyntax.OpenBracketToken;
if (openBracketToken.IsMissing ||
arrayRankSpecifierSyntax.IsMissing ||
!arrayRankSpecifierSyntax.Sizes.Any())
{
return;
}
var firstSize = arrayRankSpecifierSyntax.Sizes[0];
var firstSizeLineSpan = firstSize.GetLineSpan();
if (!firstSizeLineSpan.IsValid)
{
return;
}
var openBracketLineSpan = openBracketToken.GetLineSpan();
if (!openBracketLineSpan.IsValid)
{
return;
}
if (openBracketLineSpan.EndLinePosition.Line != firstSizeLineSpan.StartLinePosition.Line &&
openBracketLineSpan.EndLinePosition.Line != (firstSizeLineSpan.StartLinePosition.Line - 1))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, firstSize.GetLocation()));
}
}
}
//public override void VisitAccessorDeclaration(AccessorDeclarationSyntax node)
//{
// base.VisitAccessorDeclaration(node);
//}
//public override void VisitAccessorList(AccessorListSyntax node)
//{
// base.VisitAccessorList(node);
//}
//public override void VisitAliasQualifiedName(AliasQualifiedNameSyntax node)
//{
// base.VisitAliasQualifiedName(node);
//}
//public override void VisitAnonymousMethodExpression(AnonymousMethodExpressionSyntax node)
//{
// base.VisitAnonymousMethodExpression(node);
//}
//public override void VisitAnonymousObjectCreationExpression(AnonymousObjectCreationExpressionSyntax node)
//{
// base.VisitAnonymousObjectCreationExpression(node);
//}
//public override void VisitAnonymousObjectMemberDeclarator(AnonymousObjectMemberDeclaratorSyntax node)
//{
// base.VisitAnonymousObjectMemberDeclarator(node);
//}
//public override void VisitArgumentList(ArgumentListSyntax node)
//{
// base.VisitArgumentList(node);
//}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
Visit(node.Type);
Visit(node.Initializer);
//base.VisitArrayCreationExpression(node);
}
private static bool HasSizeSpecifier(ArrayCreationExpressionSyntax arrayCreation)
{
return(arrayCreation.ArrayBounds != null &&
arrayCreation.ArrayBounds.Arguments.Any());
}
private static void AddArrayCreationExpressionTerms(
ArrayCreationExpressionSyntax arrayCreationExpression,
IList<string> terms,
ref ExpressionType expressionType)
{
var validTerm = true;
if (arrayCreationExpression.Initializer != null)
{
var flags = ExpressionType.Invalid;
arrayCreationExpression.Initializer.Expressions.Do(e => AddSubExpressionTerms(e, terms, ref flags));
validTerm &= IsValidTerm(flags);
}
if (validTerm)
{
expressionType = ExpressionType.ValidExpression;
}
else
{
expressionType = ExpressionType.Invalid;
}
}
private IEnumerable<ITypeSymbol> InferTypeInArrayCreationExpression(
ArrayCreationExpressionSyntax arrayCreationExpression, SyntaxToken? previousToken = null)
{
if (previousToken.HasValue && previousToken.Value != arrayCreationExpression.NewKeyword)
{
// Has to follow the 'new' keyword.
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
var outerTypes = InferTypes(arrayCreationExpression);
return outerTypes.Where(o => o is IArrayTypeSymbol);
}
/// <summary>Called once at compilation start to register actions in the compilation context.</summary>
/// <param name="context">The analysis context.</param>
internal override void RegisterSyntaxNodeAction(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeAction(ctx =>
{
// We can't replace array allocations in attributes, as they're persisted to metadata
if (ctx.Node.Parent is AttributeArgumentSyntax)
{
return;
}
InitializerExpressionSyntax initializerExpr = null;
bool isArrayCreationExpression = ctx.Node.CSharpKind() == SyntaxKind.ArrayCreationExpression;
if (isArrayCreationExpression)
{
// This is an ArrayCreationExpression (e.g. "new byte[2]" or "new byte[] { 1, 2 }").
// If it has only a single rank, and if the input to it is a constant 0, report it.
ArrayCreationExpressionSyntax arrayCreationExpr = (ArrayCreationExpressionSyntax)ctx.Node;
var arrayType = arrayCreationExpr.Type;
if (arrayType.ElementType is PointerTypeSyntax) // pointers can't be used as generic arguments
{
return;
}
if (arrayType.RankSpecifiers.Count >= 1)
{
// Make sure this is a single dimensional array.
ArrayRankSpecifierSyntax rankSpecifier = arrayType.RankSpecifiers[0];
if (rankSpecifier.Rank != 1)
{
return;
}
// Parse out the numerical length from the rank specifier. It must be a constant zero.
LiteralExpressionSyntax sizeSpecifier = rankSpecifier.ChildNodes().FirstOrDefault(child => child.CSharpKind() == SyntaxKind.NumericLiteralExpression) as LiteralExpressionSyntax;
if (sizeSpecifier != null)
{
if (sizeSpecifier.Token.Value is int && ((int)sizeSpecifier.Token.Value) == 0)
{
Report(ctx, arrayCreationExpr);
}
return;
}
// We couldn't determine the length based on the rank specifier.
// We'll try to do so based on any initializer expression the array has.
initializerExpr = arrayCreationExpr.Initializer;
}
}
else if (!(ctx.Node.Parent is ArrayCreationExpressionSyntax))
{
// This is an ArrayInitializerExpression (e.g. { 1, 2 }). However, we only want to examine it
// if it's not part of a larger ArrayCreationExpressionSyntax; otherwise, we'll end up
// flagging it twice and recommending incorrect transforms.
initializerExpr = ctx.Node as InitializerExpressionSyntax;
}
// If we needed to examine the initializer in order to get the size and if it's 0,
// report it, but make sure to report the right syntax node.
if (initializerExpr != null && initializerExpr.Expressions.Count == 0)
{
Report(ctx, isArrayCreationExpression ? ctx.Node : initializerExpr);
}
}, expressionKinds);
}
private bool TryGenerateNewArray(ArrayCreationExpressionSyntax arrayCreationExpression)
{
var type = SemanticModel.GetTypeInfo(arrayCreationExpression).Type;
if (type == null)
{
return false;
}
using (NewArrayTag())
{
GenerateType(type);
if (arrayCreationExpression.Initializer != null)
{
using (BoundTag())
using (ExpressionTag())
using (LiteralTag())
using (NumberTag())
{
EncodedText(arrayCreationExpression.Initializer.Expressions.Count.ToString());
}
if (!TryGenerateExpression(arrayCreationExpression.Initializer))
{
return false;
}
}
else
{
foreach (var rankSpecifier in arrayCreationExpression.Type.RankSpecifiers)
{
foreach (var size in rankSpecifier.Sizes)
{
using (BoundTag())
{
if (!TryGenerateExpression(size))
{
return false;
}
}
}
}
}
}
return true;
}
public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
if (!node.IsKind(SyntaxKind.ImplicitArrayCreationExpression) &&
this.typeSymbol.Equals(this.semanticModel.GetTypeInfo(node).Type))
{
this.IsAmbiguous = false;
}
else
{
base.DefaultVisit(node);
}
}
