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