protected override IValue VisitArrayType(ArrayTypeSyntax node)
{
var info = ModelExtensions.GetTypeInfo(context.RoslynModel, node);
var t = context.Roslyn_ResolveType(info.Type);
return(new TypeValue(t));
}
public static Doc Print(ArrayTypeSyntax node)
{
return(Doc.Concat(
Node.Print(node.ElementType),
Doc.Concat(node.RankSpecifiers.Select(Node.Print).ToArray())
));
}
public static TypeSyntax Create(System.Type type)
{
if (type is null)
{
return(null);
}
TypeSyntax value;
if (type.IsArray)
{
value = new ArrayTypeSyntax(Create(type.GetElementType()), type.GetArrayRank());
}
else if (type.IsGenericType)
{
var types = type.GetGenericArguments();
NodeList <TypeSyntax> typeNodes = new NodeList <TypeSyntax>(types.Length);
foreach (var arg in types)
{
typeNodes.Add(Create(arg));
}
value = new RefTypeSyntax(type.FullName, typeNodes);
}
else
{
value = new RefTypeSyntax(type.FullName);
}
value.Type = type;
return(value);
}
public override Ust VisitArrayType(ArrayTypeSyntax node)
{
var arrayType = node.ToString().Replace(",", "][");
var result = new TypeToken(arrayType, node.GetTextSpan());
return(result);
}
private Doc PrintArrayTypeSyntax(ArrayTypeSyntax node)
{
return(Concat(
this.Print(node.ElementType),
Concat(node.RankSpecifiers.Select(this.Print).ToArray())
));
}
public ArrayTypeSyntax GenReferenceToArrayType()
{
if (_type != null)
{
return(_type);
}
List <int> ranks = new List <int> {
Rank
};
// int[][] => ArrayType(ArrayType(Int, 1), 1)
// int[][,] => ArrayType(ArrayType(Int, 2), 1)
FuzzType innerElem = ElementType;
while (innerElem is ArrayType at)
{
ranks.Add(at.Rank);
innerElem = at.ElementType;
}
_type = ArrayType(
innerElem.GenReferenceTo(),
ranks.Select(
r =>
ArrayRankSpecifier(
SeparatedList(
Enumerable.Repeat((ExpressionSyntax)OmittedArraySizeExpression(), r)))).ToSyntaxList());
return(_type);
}
private Block BuildArrayType(ArrayTypeSyntax arrayType, Block currentBlock)
{
currentBlock.ReversedInstructions.Add(arrayType);
var arraySizes = arrayType.RankSpecifiers.SelectMany(rs => rs.Sizes);
return(BuildExpressions(arraySizes, currentBlock));
}
public static void Write(ArrayTypeSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var symbol = (ITypeSymbol)context.SemanticModel.GetSymbolInfo(syntax.ElementType).Symbol;
textWriter.Write("System.Array[{");
context.TypeReferenceWriter.WriteTypeReference(symbol, textWriter);
textWriter.Write("}]");
syntax.RankSpecifiers.Single().Write(textWriter, context);
}
public override IEnumerable <IModel> VisitArrayType(ArrayTypeSyntax node)
{
var model = Create <ArrayTypeExpression>(node);
model.ElementType = GetDefinition <ITypeDefinition>(node.ElementType);
TransformInto <ArrayRankSpecifier>(node.RankSpecifiers, model.RankExpressions);
yield return(model);
}
//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)
//{
// base.VisitArrayCreationExpression(node);
//}
//public override void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node)
//{
// base.VisitArrayRankSpecifier(node);
//}
public override void VisitArrayType(ArrayTypeSyntax node)
{
foreach (ArrayRankSpecifierSyntax rankSpecifier in node.RankSpecifiers)
{
Visit(rankSpecifier);
}
//base.VisitArrayType(node);
}
public override void VisitArrayType(ArrayTypeSyntax node)
{
Visit(node.ElementType);
foreach (var rank in node.RankSpecifiers)
{
Visit(rank);
}
}
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))));
}
private void BuildArrayType(ArrayTypeSyntax arrayType)
{
var arraySizes = arrayType.RankSpecifiers.SelectMany(rs => rs.Sizes);
foreach (var arraySize in arraySizes.Reverse())
{
BuildExpression(arraySize);
}
}
public override void VisitArrayType(ArrayTypeSyntax node)
{
using (ExpressionCaptureScope arrayTypeCaptureScope = new ExpressionCaptureScope(visitorContext, visitorContext.topCaptureScope))
{
Visit(node.ElementType);
arrayTypeCaptureScope.MakeArrayType();
}
}
public override IDeclarationUse <SyntaxNode> VisitArrayType(ArrayTypeSyntax node)
{
var elementDeclarationUse = this.Visit(node.ElementType);
((IArrayDeclarationUseImpl)elementDeclarationUse).ArraySpecification = new ArraySpecification(
node.RankSpecifiers.Count,
new ParserSyntaxNodeProvider <ArrayTypeSyntax>(node));
return(elementDeclarationUse);
}
public static ArrayTypeSyntax WithOmittedRankSpecifiers(this ArrayTypeSyntax syntax) =>
syntax.WithRankSpecifiers(
SingletonList(
ArrayRankSpecifier(
SingletonSeparatedList <ExpressionSyntax>(
OmittedArraySizeExpression()
)
)
)
);
public override Evaluation VisitArrayType(ArrayTypeSyntax node)
{
node.ElementType?.Accept <Evaluation>(this);
foreach (ArrayRankSpecifierSyntax rankSpecifier in node.RankSpecifiers)
{
rankSpecifier.Accept <Evaluation>(this);
}
return(base.VisitArrayType(node));
}
public override void VisitArrayType(ArrayTypeSyntax arrayTypeSyntax)
{
Visit(arrayTypeSyntax.ElementType);
foreach (ArrayRankSpecifierSyntax rankSpecifier in arrayTypeSyntax.RankSpecifiers)
{
foreach (ExpressionSyntax rankSpecifierSize in rankSpecifier.Sizes)
{
Visit(rankSpecifierSize);
}
}
}
public new void AddChildren()
{
base.AddChildren();
Kind = Node.Kind();
_newKeyword = ((ArrayCreationExpressionSyntax)Node).NewKeyword;
_newKeywordIsChanged = false;
_type = ((ArrayCreationExpressionSyntax)Node).Type;
_typeIsChanged = false;
_initializer = ((ArrayCreationExpressionSyntax)Node).Initializer;
_initializerIsChanged = false;
}
private static ArrayCreationExpressionSyntax CreateArrayCreationExpression(
ImplicitArrayCreationExpressionSyntax node,
ArrayTypeSyntax arrayType)
{
return(SyntaxFactory.ArrayCreationExpression(
node.NewKeyword,
arrayType
.WithSimplifierAnnotation()
.WithTrailingTrivia(node.CloseBracketToken.TrailingTrivia),
node.Initializer));
}
// Protected Methods
protected override Type VisitArrayType(ArrayTypeSyntax node)
{
var ranks = node.RankSpecifiers.Select(i => i.Rank).ToArray();
var et = Visit(node.ElementType);
foreach (var i in ranks)
{
et = et.MakeArrayType(i);
}
return(et);
}
private void BuildArrayType(ArrayTypeSyntax arrayType)
{
currentBlock.ReversedInstructions.Add(arrayType);
var arraySizes = arrayType.RankSpecifiers.SelectMany(rs => rs.Sizes);
foreach (var arraySize in arraySizes.Reverse())
{
BuildExpression(arraySize);
}
}
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 void VisitArrayType(ArrayTypeSyntax node)
{
using (ExpressionCaptureScope arrayTypeCaptureScope = new ExpressionCaptureScope(visitorContext, visitorContext.topCaptureScope))
{
Visit(node.ElementType);
for (int i = 0; i < node.RankSpecifiers.Count; ++i)
{
arrayTypeCaptureScope.MakeArrayType();
}
}
}
public override void VisitArrayType(ArrayTypeSyntax node)
{
Information.Add(InfoExtractor.Info.TYPE, node);
node.ElementType?.Accept(this);
foreach (ArrayRankSpecifierSyntax rankSpecifier in node.RankSpecifiers)
{
rankSpecifier.Accept(this);
}
base.VisitArrayType(node);
}
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);
}
private static void AnalyzeArrayCreationExpression(SyntaxNodeAnalysisContext context)
{
var arrayCreation = (ArrayCreationExpressionSyntax)context.Node;
if (arrayCreation.ContainsDiagnostics)
{
return;
}
ArrayTypeSyntax arrayType = arrayCreation.Type;
if (arrayType.ContainsDirectives)
{
return;
}
SeparatedSyntaxList <ExpressionSyntax> expressions = arrayCreation.Initializer?.Expressions ?? default;
if (!expressions.Any())
{
return;
}
if (AnalyzerOptions.UseImplicitlyTypedArrayWhenTypeIsObvious.IsEnabled(context))
{
foreach (ExpressionSyntax expression in expressions)
{
if (!CSharpTypeAnalysis.IsTypeObvious(expression, null, context.SemanticModel, context.CancellationToken))
{
return;
}
}
}
TypeSyntax elementType = arrayType.ElementType;
SyntaxList <ArrayRankSpecifierSyntax> rankSpecifiers = arrayType.RankSpecifiers;
TextSpan textSpan = TextSpan.FromBounds(
elementType.SpanStart,
((rankSpecifiers.Count > 1) ? rankSpecifiers.LastButOne() : (SyntaxNode)elementType).Span.End);
Location location = Location.Create(arrayCreation.SyntaxTree, textSpan);
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.ReportOnly.UseImplicitlyTypedArray,
location);
DiagnosticHelpers.ReportObsolete(context, location, AnalyzerOptions.UseImplicitlyTypedArray);
DiagnosticHelpers.ReportObsolete(context, location, AnalyzerOptions.UseImplicitlyTypedArrayWhenTypeIsObvious);
}
public TypeStructure ConvertTypeStructure(TypeSyntax syntax)
{
return(syntax switch
{
PredefinedTypeSyntax ptSyntax => ToPredefinedIdentifierStructure(ptSyntax.Keyword.Text),
IdentifierNameSyntax inSyntax => ToIdentifierStructure(inSyntax, _typeLocator),
QualifiedNameSyntax qnSyntax => ToIdentifierStructure(qnSyntax),
GenericNameSyntax gnSyntax => ToGenericTypeStructure(gnSyntax),
ArrayTypeSyntax atSyntax => ToArrayTypeStructure(atSyntax),
PointerTypeSyntax ptSyntax => ToPointerTypeStructure(ptSyntax),
NullableTypeSyntax ntSyntax => ToNullableTypeStructure(ntSyntax),
TupleTypeSyntax ttSyntax => ToTupleTypeStructure(ttSyntax),
_ => throw new ArgumentException(syntax.GetType().ToString())
});
public override TypeWithNode VisitArrayType(ArrayTypeSyntax node)
{
var elementType = node.ElementType.Accept(this);
var arrayType = elementType.Type != null?semanticModel.Compilation.CreateArrayTypeSymbol(elementType.Type) : null;
// in an ArrayCreationExpression, the rank specifiers may contain arbitrary sub-expressions
foreach (var rank in node.RankSpecifiers)
{
rank.Accept(this);
}
var nullNode = CanBeMadeNullableSyntax(node) ? Mapping.CreateNewNode(node) : typeSystem.ObliviousNode;
return(new TypeWithNode(arrayType, nullNode, new[] { elementType }));
}
private static async Task <Document> RefactorAsync(
Document document,
ImplicitArrayCreationExpressionSyntax node,
ArrayTypeSyntax arrayType,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
ArrayCreationExpressionSyntax newNode = CreateArrayCreationExpression(node, arrayType)
.WithFormatterAnnotation();
SyntaxNode newRoot = root.ReplaceNode(node, newNode);
return(document.WithSyntaxRoot(newRoot));
}
public static string ArrayType(ArrayTypeSyntax array)
{
return "[" + SyntaxNode(array.ElementType) + "]"; //TODO: rankspecifiers
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitArrayType(ArrayTypeSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitArrayType(node);
}
internal static bool IsArgumentListToken(ArrayTypeSyntax node, SyntaxToken token)
{
return node.RankSpecifiers.Span.Contains(token.SpanStart) &&
token != node.RankSpecifiers.First().CloseBracketToken;
}
public override void VisitArrayType(ArrayTypeSyntax node)
{
this.seenConstructed = true;
Visit(node.ElementType);
}
public void VisitArrayType(ArrayTypeSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
ExpressionStart(node);
node.ElementType.Accept(this);
foreach (var rankSpecifier in node.RankSpecifiers)
{
rankSpecifier.Accept(this);
}
ExpressionEnd(node);
}
public virtual void PostWalkArrayType(ArrayTypeSyntax arrayTypeSyntax) { }
// ArrayTypeSyntax
public virtual bool WalkArrayType(ArrayTypeSyntax arrayTypeSyntax) { return DefaultWalk(arrayTypeSyntax); }
private IEnumerable<ITypeSymbol> InferTypeInArrayType(ArrayTypeSyntax arrayType, SyntaxToken? previousToken = null)
{
if (previousToken.HasValue)
{
// TODO(cyrusn): NYI. Handle this appropriately if we need to.
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
// Bind the array type, then unwrap whatever we get back based on the number of rank
// specifiers we see.
var currentTypes = InferTypes(arrayType);
for (var i = 0; i < arrayType.RankSpecifiers.Count; i++)
{
currentTypes = currentTypes.OfType<IArrayTypeSymbol>().Select(c => c.ElementType);
}
return currentTypes;
}
public ArrayTypeTranslation(ArrayTypeSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
RankSpecifiers = syntax.RankSpecifiers.Get<ArrayRankSpecifierSyntax, ArrayRankSpecifierTranslation>(this);
ElementType = syntax.ElementType.Get<TypeTranslation>(this);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitArrayType(ArrayTypeSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitArrayType(node);
}
public override SyntaxNode VisitArrayType(ArrayTypeSyntax node)
{
bool oldAlwaysSimplify = this.alwaysSimplify;
if (!this.alwaysSimplify)
{
this.alwaysSimplify = node.HasAnnotation(Simplifier.Annotation);
}
var result = base.VisitArrayType(node);
this.alwaysSimplify = oldAlwaysSimplify;
return result;
}
public virtual void Visit(ArrayTypeSyntax arrayTypeSyntax)
{
}
