public static void Go(OutputWriter writer, ImplicitArrayCreationExpressionSyntax array) { var ti = TypeProcessor.GetTypeInfo(array); var t = ti.Type; if (ti.ConvertedType != null && !(ti.ConvertedType == t)) // Alot of times we are using covariance here { t = ti.ConvertedType; } var ptr = !t.As <IArrayTypeSymbol>().ElementType.IsValueType; // ? "" : ""; var elementType = t.As <IArrayTypeSymbol>().ElementType; var type = TypeProcessor.ConvertType(elementType); var typeString = "Array_T!(" + type + ")"; var tempWriter = new TempWriter(); tempWriter.Indent = writer.Indent; if (elementType.TypeKind == TypeKind.TypeParameter) { tempWriter.Write(" __TypeNew!(" + typeString + ")(["); } else { tempWriter.Write("new " + typeString + "("); } //__ARRAY var variableDeclarationSyntax = array.Parent.Parent.Parent as VariableDeclarationSyntax; // var argumentSyntax = array.Parent as ArgumentSyntax; if (variableDeclarationSyntax != null) { var atype = variableDeclarationSyntax.Type; array.Initializer.WriteArrayInitializer(tempWriter, atype); } else { array.Initializer.WriteArrayInitializer(tempWriter, t); } tempWriter.Write(")"); var tempString = tempWriter.ToString(); var oldString = tempString; tempString = tempString.Replace("new " + typeString + "(__CC!(" + type + "[])(", "__ARRAY!(" + type + ")("); if (tempString != oldString) { tempString = tempString.RemoveFromEndOfString(")"); } writer.Write(tempString); }
public static async Task <Document> RefactorAsync( Document document, ImplicitArrayCreationExpressionSyntax implicitArrayCreation, CancellationToken cancellationToken = default) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitArrayCreation, cancellationToken); var arrayType = (ArrayTypeSyntax)typeSymbol.ToTypeSyntax().WithSimplifierAnnotation(); SyntaxToken newKeyword = implicitArrayCreation.NewKeyword; if (!newKeyword.HasTrailingTrivia) { newKeyword = newKeyword.WithTrailingTrivia(SyntaxFactory.Space); } ArrayCreationExpressionSyntax newNode = SyntaxFactory.ArrayCreationExpression( newKeyword, arrayType .WithLeadingTrivia(implicitArrayCreation.OpenBracketToken.LeadingTrivia) .WithTrailingTrivia(implicitArrayCreation.CloseBracketToken.TrailingTrivia), implicitArrayCreation.Initializer); return(await document.ReplaceNodeAsync(implicitArrayCreation, newNode, cancellationToken).ConfigureAwait(false)); }
public static void Go(ScalaWriter writer, ImplicitArrayCreationExpressionSyntax array) { writer.Write("Array"); //var t = Program.GetModel(array).GetTypeInfo(array).Type; //if (t is IArrayTypeSymbol) //{ // writer.Write("["); // writer.Write(TypeProcessor.ConvertType(t.As<IArrayTypeSymbol>().ElementType)); // writer.Write("]"); //} writer.Write("("); bool first = true; foreach (var expression in array.Initializer.Expressions) { if (first) { first = false; } else { writer.Write(", "); } Core.Write(writer, expression); } writer.Write(")"); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); ImplicitArrayCreationExpressionSyntax expression = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <ImplicitArrayCreationExpressionSyntax>(); if (expression != null && context.Document.SupportsSemanticModel) { SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); var typeSymbol = semanticModel .GetTypeInfo(expression, context.CancellationToken) .Type as IArrayTypeSymbol; if (typeSymbol?.ElementType?.IsErrorType() == false) { var arrayType = CSharpFactory.Type(typeSymbol) as ArrayTypeSyntax; if (arrayType != null) { CodeAction codeAction = CodeAction.Create( $"Declare explicit type '{typeSymbol.ToMinimalDisplayString(semanticModel, expression.Span.Start, SyntaxUtility.DefaultSymbolDisplayFormat)}'", cancellationToken => RefactorAsync(context.Document, expression, arrayType, cancellationToken), DiagnosticIdentifiers.AvoidImplicitlyTypedArray + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); } } } }
public static string ImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax array) { var output = "[ "; output += array.Initializer.Expressions.ConvertSeparatedSyntaxList(); return(output + " ]"); }
public static string ImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var output = "[ "; output += string.Join(", ", node.Initializer.Expressions.Select(SyntaxNode)); return(output + " ]"); }
public override IStmt VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { return(new IndexExpr { Elements = node.Initializer.Expressions.Select(Visit).ToArray() }); }
private static async Task <Document> ChangeArrayTypeToExplicitAsync( Document document, ImplicitArrayCreationExpressionSyntax implicitArrayCreation, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(implicitArrayCreation, cancellationToken); var arrayType = (ArrayTypeSyntax)typeSymbol.ToTypeSyntax().WithSimplifierAnnotation(); SyntaxToken newKeyword = implicitArrayCreation.NewKeyword; if (!newKeyword.HasTrailingTrivia) { newKeyword = newKeyword.WithTrailingTrivia(Space); } InitializerExpressionSyntax initializer = implicitArrayCreation.Initializer; InitializerExpressionSyntax newInitializer = initializer.ReplaceNodes( initializer.Expressions, (node, _) => (node.IsKind(SyntaxKind.CastExpression)) ? node.WithSimplifierAnnotation() : node); ArrayCreationExpressionSyntax newNode = ArrayCreationExpression( newKeyword, arrayType .WithLeadingTrivia(implicitArrayCreation.OpenBracketToken.LeadingTrivia) .WithTrailingTrivia(implicitArrayCreation.CloseBracketToken.TrailingTrivia), newInitializer); return(await document.ReplaceNodeAsync(implicitArrayCreation, newNode, cancellationToken).ConfigureAwait(false)); }
public override BoundNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { if (node.Commas.Count != 0) { throw new NotSupportedException( "Multidimensional arrays are not yet supported by UdonSharp, consider using jagged arrays instead.", node.GetLocation()); } // Almost certainly needs to be revisited for jagged arrays TypeSymbol arrayType = GetTypeSymbol(node); var initializerExpressions = node.Initializer.Expressions; BoundExpression[] elementCounts = { new BoundConstantExpression(new ConstantValue <int>(initializerExpressions.Count), Context.GetTypeSymbol(SpecialType.System_Int32), node) }; BoundExpression[] initializers = new BoundExpression[initializerExpressions.Count]; TypeSymbol elementType = arrayType.ElementType; for (int i = 0; i < initializers.Length; ++i) { initializers[i] = VisitExpression(initializerExpressions[i], elementType); } return(new BoundArrayCreationExpression(node, Context, arrayType, elementCounts, initializers)); }
public override IEnumerable <IModel> VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var model = Create <ImplicitArrayCreationExpression>(node); model.Initializer = TransformToSingle <InitializerExpression>(node.Initializer); yield return(model); }
public static void Write(this ImplicitArrayCreationExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context) { var typeInfo = context.SemanticModel.GetTypeInfo(syntax); textWriter.Write("("); context.TypeReferenceWriter.WriteInteractionElementReference(typeInfo.Type, textWriter); textWriter.Write("._C_0_0() % _M.DOT)"); syntax.Initializer.Write(textWriter, context); }
private IEnumerable <Instruction> ProcessImplicitArrayCreation(ImplicitArrayCreationExpressionSyntax implicitArrayExpression) { // e.g. string[] a2 = new[] { data, data } // Need to look at the ConvertedType in this case since the implicit array creation type is null if (!(this.semanticModel.GetTypeInfo(implicitArrayExpression).ConvertedType is IArrayTypeSymbol arrayType)) { return(NoInstructions); } return(BuildNewArrayInstance(implicitArrayExpression, arrayType)); }
public override SyntaxNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { if (NormalizeWhitespaceOnly && _checkingMethod != RegisterInstanceName) { var closeBracket = node.CloseBracketToken.WithTrailingTrivia(SyntaxHelper.EndOfLineTrivia); node = node.WithCloseBracketToken(closeBracket); node = node.WithInitializer(RewriteInitializer(node.Initializer)); } return(base.VisitImplicitArrayCreationExpression(node)); }
private static ArrayCreationExpressionSyntax CreateArrayCreationExpression( ImplicitArrayCreationExpressionSyntax node, ArrayTypeSyntax arrayType) { return(SyntaxFactory.ArrayCreationExpression( node.NewKeyword, arrayType .WithSimplifierAnnotation() .WithTrailingTrivia(node.CloseBracketToken.TrailingTrivia), node.Initializer)); }
public override Ust VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var type = new TypeToken(CommonUtils.Prefix + "object", node.NewKeyword.GetTextSpan()); var sizes = node.Commas.Select(c => new IntLiteral(0, c.GetTextSpan())).ToList(); sizes.Add(new IntLiteral(0, node.CloseBracketToken.GetTextSpan())); var result = new ArrayCreationExpression(type, sizes, new Expression[0], node.GetTextSpan()); return(result); }
public override SyntaxNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var type = sem.GetTypeInfo(node).Type; var newNode = (ImplicitArrayCreationExpressionSyntax)base.VisitImplicitArrayCreationExpression(node); var arrayType = ArrayType(ParseTypeName(type.ToDisplayString(displayFormat)).WithLeadingTrivia(Space)); return(ArrayCreationExpression(arrayType) .WithInitializer(newNode.Initializer) .WithTriviaFrom(newNode)); }
public static void Go(OutputWriter writer, ImplicitArrayCreationExpressionSyntax array) { var ti = TypeProcessor.GetTypeInfo(array); var t = ti.Type; if (ti.ConvertedType!=null && !(ti.ConvertedType == t)) // Alot of times we are using covariance here { t = ti.ConvertedType; } var ptr = !t.As<IArrayTypeSymbol>().ElementType.IsValueType; // ? "" : ""; var elementType = t.As<IArrayTypeSymbol>().ElementType; var type = TypeProcessor.ConvertType(elementType); var typeString = "Array_T!(" + type + ")"; var tempWriter = new TempWriter(); tempWriter.Indent = writer.Indent; if (elementType.TypeKind == TypeKind.TypeParameter) tempWriter.Write(" __TypeNew!(" + typeString + ")(["); else { tempWriter.Write("new " + typeString + "("); } //__ARRAY var variableDeclarationSyntax = array.Parent.Parent.Parent as VariableDeclarationSyntax; // var argumentSyntax = array.Parent as ArgumentSyntax; if (variableDeclarationSyntax != null) { var atype = variableDeclarationSyntax.Type; array.Initializer.WriteArrayInitializer(tempWriter, atype); } else array.Initializer.WriteArrayInitializer(tempWriter,t); tempWriter.Write(")"); var tempString = tempWriter.ToString(); var oldString = tempString; tempString = tempString.Replace("new " + typeString + "(__CC!(" + type + "[])(", "__ARRAY!(" + type + ")("); if (tempString != oldString) tempString = tempString.RemoveFromEndOfString(")"); writer.Write(tempString); }
public static Doc Print(ImplicitArrayCreationExpressionSyntax node) { var commas = node.Commas.Select(Token.Print).ToArray(); return(Doc.Concat( Token.Print(node.NewKeyword), Token.Print(node.OpenBracketToken), Doc.Concat(commas), Token.Print(node.CloseBracketToken, " "), Node.Print(node.Initializer) )); }
public override JsExpression VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var type = (IArrayTypeSymbol)model.GetTypeInfo(node).ConvertedType; var elementType = type.ElementType; var newArrayInit = GetExpressionMethod("NewArrayInit", Context.Instance.TypeType, Context.Instance.ExpressionArray); var jsMethod = idioms.InvokeStatic( newArrayInit, idioms.TypeOf(elementType), idioms.Array(Context.Instance.ExpressionArray, node.Initializer.Expressions.Select(x => x.Accept(this)).ToArray())); return(jsMethod); }
public override void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { if (!PreVisit(node)) { return; } node.Initializer?.Accept(this); base.VisitImplicitArrayCreationExpression(node); PostVisit(node); }
private Doc PrintImplicitArrayCreationExpressionSyntax( ImplicitArrayCreationExpressionSyntax node) { var commas = node.Commas.Select(o => this.PrintSyntaxToken(o)) .ToArray(); return(Concat( this.PrintSyntaxToken(node.NewKeyword), this.PrintSyntaxToken(node.OpenBracketToken), Concat(commas), this.PrintSyntaxToken(node.CloseBracketToken, " "), this.Print(node.Initializer) )); }
private static async Task FindAnonymousTypesWithMessageContractsInTree(IDictionary <AnonymousObjectCreationExpressionSyntax, ITypeSymbol> dictionary, ImplicitArrayCreationExpressionSyntax implicitArrayCreationExpressionSyntax, ITypeSymbol contractElementType, SemanticModel semanticModel) { SeparatedSyntaxList <ExpressionSyntax> expressions = implicitArrayCreationExpressionSyntax.Initializer.Expressions; foreach (var expression in expressions) { if (expression is AnonymousObjectCreationExpressionSyntax anonymousObjectArrayInitializer) { await FindAnonymousTypesWithMessageContractsInTree(dictionary, anonymousObjectArrayInitializer, contractElementType, semanticModel).ConfigureAwait(false); } } }
public override LuaSyntaxNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var symbol = semanticModel_.GetTypeInfo(node.Initializer.Expressions.First()).Type; LuaExpressionSyntax elementTypeExpression = GetTypeName(symbol); LuaInvocationExpressionSyntax arrayTypeExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Array, elementTypeExpression); LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(arrayTypeExpression); foreach (var expression in node.Initializer.Expressions) { var element = (LuaExpressionSyntax)expression.Accept(this); invocation.AddArgument(element); } return(invocation); }
private static async Task <Document> SpecifyExplicitTypeAsync( Document document, ImplicitArrayCreationExpressionSyntax node, ArrayTypeSyntax arrayType, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken); ArrayCreationExpressionSyntax newNode = CreateArrayCreationExpression(node, arrayType) .WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode newRoot = oldRoot.ReplaceNode(node, newNode); return(document.WithSyntaxRoot(newRoot)); }
public override void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { var arrayType = Context.GetTypeInfo(node); if (arrayType.Type == null) { throw new Exception($"Unable to infer array type: {node}"); } AddCilInstruction(ilVar, OpCodes.Ldc_I4, node.Initializer.Expressions.Count); var arrayTypeSymbol = (IArrayTypeSymbol)arrayType.Type; ProcessArrayCreation(arrayTypeSymbol.ElementType, node.Initializer); }
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 void Go(OutputWriter writer, ImplicitArrayCreationExpressionSyntax array) { var t = TypeProcessor.GetTypeInfo(array).Type; var ptr = !t.As <IArrayTypeSymbol>().ElementType.IsValueType; // ? "" : ""; var elementType = t.As <IArrayTypeSymbol>().ElementType; 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 = array.Parent.Parent.Parent as VariableDeclarationSyntax; if (variableDeclarationSyntax != null) { var atype = variableDeclarationSyntax.Type; array.Initializer.WriteArrayInitializer(writer, atype); } else { array.Initializer.WriteArrayInitializer(writer); } // array.Initializer.WriteArrayInitializer(writer,); // bool first = true; // foreach (var expression in array.Initializer.Expressions) // { // if (first) // first = false; // else // writer.Write(","); // // Core.Write(writer, expression); // } writer.Write(")"); }
public static int?TryGetSizeOfSingleDimensionalNonJaggedArray(ExpressionSyntax?arrayCreationExpression, SemanticModel?semanticModel = null, CancellationToken cancellationToken = default) { return(arrayCreationExpression switch { ArrayCreationExpressionSyntax arrayCreation when arrayCreation.Initializer != null => arrayCreation.Initializer.Expressions.Count, ArrayCreationExpressionSyntax arrayCreationWithouInitializer => TryGetSizeOfSingleDimensionalNonJaggedArray(arrayCreationWithouInitializer.Type, semanticModel, cancellationToken), ImplicitArrayCreationExpressionSyntax implicitArrayCreation => implicitArrayCreation.Initializer?.Expressions.Count, InitializerExpressionSyntax initializerExpression when initializerExpression.IsKind(SyntaxKind.ArrayInitializerExpression) => initializerExpression.Expressions.Count, StackAllocArrayCreationExpressionSyntax stackAllocArrayCreation when stackAllocArrayCreation.Type is ArrayTypeSyntax arrayType => TryGetSizeOfSingleDimensionalNonJaggedArray(arrayType, semanticModel, cancellationToken), _ => null });
public static async Task <Document> RefactorAsync( Document document, ImplicitArrayCreationExpressionSyntax expression, CancellationToken cancellationToken = default(CancellationToken)) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, cancellationToken); var arrayType = CSharpFactory.Type(typeSymbol, semanticModel, expression.SpanStart) as ArrayTypeSyntax; ArrayCreationExpressionSyntax newNode = SyntaxFactory.ArrayCreationExpression( expression.NewKeyword, arrayType.WithTrailingTrivia(expression.CloseBracketToken.TrailingTrivia), expression.Initializer); newNode = newNode.WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(expression, newNode, cancellationToken).ConfigureAwait(false)); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); ImplicitArrayCreationExpressionSyntax node = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <ImplicitArrayCreationExpressionSyntax>(); if (node == null) { return; } SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken); if (semanticModel == null) { return; } ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(node, context.CancellationToken).Type; if (typeSymbol == null) { return; } var arrayType = TypeSyntaxRefactoring.CreateTypeSyntax(typeSymbol) as ArrayTypeSyntax; if (arrayType == null) { return; } CodeAction codeAction = CodeAction.Create( $"Declare explicit type '{typeSymbol.ToDisplayString(TypeSyntaxRefactoring.SymbolDisplayFormat)}'", cancellationToken => SpecifyExplicitTypeAsync(context.Document, node, arrayType, cancellationToken), DiagnosticIdentifiers.AvoidImplicitArrayCreation + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
private async Task <Document> SimplifyParamsParametersAsync( Document document, ImplicitArrayCreationExpressionSyntax newArray, CancellationToken cancellationToken) { var arg = (ArgumentSyntax)newArray.Parent; var argList = (ArgumentListSyntax)arg.Parent; var argListWithoutParamsArray = argList.Arguments.Remove(arg); ArgumentListSyntax resultingArgs = SyntaxFactory.ArgumentList( argListWithoutParamsArray .AddRange(newArray.Initializer.Expressions.Select(SyntaxFactory.Argument))); // Replace the old local declaration with the new local declaration. var oldRoot = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = oldRoot.ReplaceNode(argList, resultingArgs); // Return document with transformed tree. return(document.WithSyntaxRoot(newRoot)); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitImplicitArrayCreationExpression(node); }
public override void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { base.VisitImplicitArrayCreationExpression(node); }
public ImplicitArrayCreationExpressionTranslation(ImplicitArrayCreationExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Initializer = syntax.Initializer.Get<InitializerExpressionTranslation>(this); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitImplicitArrayCreationExpression(node); }
public static string ImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax array) { var output = "[ "; output += string.Join(", ", array.Initializer.Expressions.Select(SyntaxNode)); return output + " ]"; }
public void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax 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.WriteSyntax(Syntax.OpenBracket); for (int i = 0; i < node.Commas.GetValueOrDefault(0); i++) { _writer.WriteListSeparator(); } _writer.WriteSyntax(Syntax.CloseBracket); _writer.PushBraceFormatting(_writer.Configuration.BracesLayout.ArrayAndObjectInitializer, false); node.Initializer.Accept(this); _writer.PopBraceFormatting(); if (_writer.Configuration.Other.AlignMultiLineConstructs.ArrayObjectCollectionInitializer) _writer.SetAlignmentBreak(false); ExpressionEnd(node); }