private static void AppendArrayType(IArrayTypeSymbol symbol, StringBuilder builder) { builder.Append(GetMetadataName(symbol.ElementType)); builder.Append('['); builder.Append(',', symbol.Rank - 1); builder.Append(']'); }
public override bool VisitArrayType(IArrayTypeSymbol symbol) { if (symbol.NullableAnnotation() == NullableAnnotation.None) { return(true); } return(Visit(symbol.ElementType)); }
public override void VisitArrayType(IArrayTypeSymbol symbol) { if (!_visited.Add(symbol)) { return; } symbol.ElementType.Accept(this); }
public override void VisitArrayType(IArrayTypeSymbol symbol) { if (!visited.Add(symbol)) { return; } symbol.ElementType.Accept(this); }
private IEnumerable <Instruction> BuildNewArrayInstance(ExpressionSyntax syntaxNode, IArrayTypeSymbol arrayTypeSymbol, InitializerExpressionSyntax arrayInitializationNode) { var newInstructions = BuildNewInstance(syntaxNode, arrayTypeSymbol); var callTarget = expressionService.GetOrDefault(syntaxNode); return(newInstructions.Concat(ProcessArrayInitializer(arrayInitializationNode, callTarget))); }
public static bool ContainsAnonymousType([NotNullWhen(returnValue: true)] this ITypeSymbol?symbol) { return(symbol switch { IArrayTypeSymbol a => ContainsAnonymousType(a.ElementType), IPointerTypeSymbol p => ContainsAnonymousType(p.PointedAtType), INamedTypeSymbol n => ContainsAnonymousType(n), _ => false, });
public SendSizeComplexArrayInvokationExpressionEmitter([NotNull] IArrayTypeSymbol arraySymbol, ISymbol member, PrimitiveSizeType sizeType, SerializationMode mode) : base(arraySymbol, member, mode) { if (!Enum.IsDefined(typeof(PrimitiveSizeType), sizeType)) { throw new InvalidEnumArgumentException(nameof(sizeType), (int)sizeType, typeof(PrimitiveSizeType)); } SizeType = sizeType; }
/// <summary> /// Constructs an array suffix string for this array type symbol. /// </summary> /// <param name="trapFile">The trap builder used to store the result.</param> public static void BuildArraySuffix(this IArrayTypeSymbol array, TextWriter trapFile) { trapFile.Write('['); for (int i = 0; i < array.Rank - 1; i++) { trapFile.Write(','); } trapFile.Write(']'); }
public override TypeSyntax VisitArrayType(IArrayTypeSymbol symbol) { ThrowIfNameOnly(); ITypeSymbol underlyingType = symbol; while (underlyingType is IArrayTypeSymbol innerArray) { underlyingType = innerArray.ElementType; #if !CODE_STYLE // TODO: Remove the #if once NullableAnnotation is available. // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support if (underlyingType.NullableAnnotation == NullableAnnotation.Annotated) { // If the inner array we just moved to is also nullable, then // we must terminate the digging now so we produce the syntax for that, // and then append the ranks we passed through at the end. This is because // nullability annotations acts as a "barrier" where we won't reorder array // through. So whereas: // // string[][,] // // is really an array of rank 1 that has an element of rank 2, // // string[]?[,] // // is really an array of rank 2 that has nullable elements of rank 1. break; } #endif } var elementTypeSyntax = underlyingType.GenerateTypeSyntax(); var ranks = new List <ArrayRankSpecifierSyntax>(); var arrayType = symbol; while (arrayType != null && !arrayType.Equals(underlyingType)) { ranks.Add(SyntaxFactory.ArrayRankSpecifier( SyntaxFactory.SeparatedList(Enumerable.Repeat <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression(), arrayType.Rank)))); arrayType = arrayType.ElementType as IArrayTypeSymbol; } TypeSyntax arrayTypeSyntax = SyntaxFactory.ArrayType(elementTypeSyntax, ranks.ToSyntaxList()); #if !CODE_STYLE // TODO: Remove the #if once NullableAnnotation is available. // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support if (symbol.NullableAnnotation == NullableAnnotation.Annotated) { arrayTypeSyntax = SyntaxFactory.NullableType(arrayTypeSyntax); } #endif return(AddInformationTo(arrayTypeSyntax, symbol)); }
public ArrayCreationExpression(IArrayTypeSymbol arrayType, ImmutableArray <IOperation> elementValues, SyntaxNode syntax) : this(arrayType.ElementType, ImmutableArray.Create <IOperation>(new LiteralExpression(elementValues.Count(), resultType : null, syntax : syntax)), new ArrayInitializer(elementValues, elementValues.Any(v => v.IsInvalid), syntax, arrayType, default(Optional <object>)), syntax, arrayType, default(Optional <object>)) { }
public override bool VisitArrayType(IArrayTypeSymbol symbol) { if (!_visited.Add(symbol)) { return(false); } return(symbol.ElementType.Accept(this)); }
/// <summary> /// Constructs an array suffix string for this array type symbol. /// </summary> /// <param name="tb">The trap builder used to store the result.</param> public static void BuildArraySuffix(this IArrayTypeSymbol array, ITrapBuilder tb) { tb.Append("["); for (int i = 0; i < array.Rank - 1; i++) { tb.Append(","); } tb.Append("]"); }
private void VisitArrayType(IArrayTypeSymbol symbol, TypeSymbolWithAnnotations typeOpt) { if (TryAddAlias(symbol, builder)) { return; } //See spec section 12.1 for the order of rank specifiers //e.g. int[][,][,,] is stored as // ArrayType // Rank = 1 // ElementType = ArrayType // Rank = 2 // ElementType = ArrayType // Rank = 3 // ElementType = int if (format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.ReverseArrayRankSpecifiers)) { // Ironically, reverse order is simpler - we just have to recurse on the element type and then add a rank specifier. symbol.ElementType.Accept(this); AddArrayRank(symbol); return; } TypeSymbolWithAnnotations underlyingTypeWithAnnotations; ITypeSymbol underlyingType = symbol; do { underlyingTypeWithAnnotations = (underlyingType as ArrayTypeSymbol)?.ElementType ?? default; underlyingType = ((IArrayTypeSymbol)underlyingType).ElementType; }while (underlyingType.Kind == SymbolKind.ArrayType && !ShouldAddNullableAnnotation(underlyingTypeWithAnnotations)); if (underlyingTypeWithAnnotations.HasType) { VisitTypeSymbolWithAnnotations(underlyingTypeWithAnnotations); } else { underlyingType.Accept(this.NotFirstVisitor); } var arrayType = symbol; while (arrayType != null && arrayType != underlyingType) { if (!this.isFirstSymbolVisited) { AddCustomModifiersIfRequired(arrayType.CustomModifiers, leadingSpace: true); } AddArrayRank(arrayType); arrayType = arrayType.ElementType as IArrayTypeSymbol; } }
public void ReturnsTrue_When_HasNoConstraints() { IArrayTypeSymbol type = GetSymbol(); Mock <ITypeParameterSymbol> parameter = new(); parameter.SetupGet(p => p.Name).Returns("T"); parameter.SetupGet(p => p.ConstraintTypes).Returns(ImmutableArray.Create <ITypeSymbol>()); Assert.True(type.IsValidForTypeParameter(parameter.Object)); }
public void ReturnsFalse_When_DoesNotInheritFromConstrainedType() { IArrayTypeSymbol type = GetSymbol(); Mock <ITypeParameterSymbol> parameter = new(); parameter.SetupGet(p => p.Name).Returns("T"); parameter.SetupGet(p => p.ConstraintTypes).Returns(ImmutableArray.Create <ITypeSymbol>(Compilation.CurrentCompilation.GetTypeByMetadataName("System.Collections.ArrayList") !)); Assert.False(type.IsValidForTypeParameter(parameter.Object)); }
public override ITypeSymbol VisitArrayType(IArrayTypeSymbol symbol) { var elementType = symbol.ElementType.Accept(this); if (elementType != null && elementType.Equals(symbol.ElementType)) { return(symbol); } return(_compilation.CreateArrayTypeSymbol(elementType)); }
public void ThrowsArgumentNullException_When_ArrayTypelIsNull() { IArrayTypeSymbol type = null !; Mock <ITypeParameterSymbol> parameter = new(); parameter.SetupGet(p => p.Name).Returns("T"); parameter.SetupGet(p => p.ConstraintTypes).Returns(ImmutableArray.Create <ITypeSymbol>()); Assert.Throws <ArgumentNullException>(() => type.IsValidForTypeParameter(parameter.Object)); }
public FixedSizePrimitiveArrayInvokationExpressionEmitter([NotNull] IArrayTypeSymbol arraySymbol, ISymbol member, int knownSize, SerializationMode mode) : base(arraySymbol, member, mode) { KnownSize = knownSize; if (!arraySymbol.ElementType.IsPrimitive()) { throw new InvalidOperationException($"Type: {arraySymbol.ElementType.Name} must be primitive."); } }
public static ITypeInfo CreateFrom(ITypeSymbol typeSymbol, Compilation compilation) { typeSymbol.EnsureNotError(); return(typeSymbol switch { IArrayTypeSymbol array => new SymbolArrayTypeInfo(array, compilation), INamedTypeSymbol named when named.TypeArguments.Any() /*ne IsGenericType legyen*/ => new SymbolGenericTypeInfo(named, compilation), _ => new SymbolTypeInfo(typeSymbol, compilation) });
static void MakeArray(IArrayTypeSymbol array, List <GenericSerializationInfo> list) { var arrayInfo = new GenericSerializationInfo { FormatterName = $"global::MessagePack.Formatters.ArrayFormatter<{array.ElementType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}>()", FullName = array.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), }; list.Add(arrayInfo); }
public void ReturnsFalse_When_HasUnmanagedConstraint() { IArrayTypeSymbol type = GetSymbol(); Mock <ITypeParameterSymbol> parameter = new(); parameter.SetupGet(p => p.Name).Returns("T"); parameter.SetupGet(p => p.ConstraintTypes).Returns(ImmutableArray.Create <ITypeSymbol>()); parameter.SetupGet(p => p.HasUnmanagedTypeConstraint).Returns(true); Assert.False(type.IsValidForTypeParameter(parameter.Object)); }
public override string VisitArrayType(IArrayTypeSymbol symbol) { if (symbol.Rank == 1) { return(symbol.ElementType.Accept(this) + "[]"); } else { return(symbol.ElementType.Accept(this) + "[" + new string(',', symbol.Rank - 1) + "]"); } }
///<summary>Array types can only be one dimensional and not System.Array, ///and there are some types not usable in the Windows Runtime, like KeyValuePair</summary> ///<param name="typeSymbol">The type to check</param><param name="loc">where the type is</param> ///<param name="memberId">The method or property with this type in its signature</param> /// <param name="typeId">the type this member (method/prop) lives in</param> private void ReportIfInvalidType(ITypeSymbol typeSymbol, Location loc, SyntaxToken memberId, SyntaxToken typeId) { // If it's of the form int[], it has to be one dimensional if (typeSymbol.TypeKind == TypeKind.Array) { IArrayTypeSymbol arrTypeSym = (IArrayTypeSymbol)typeSymbol; // [,,]? if (arrTypeSym.Rank > 1) { Report(WinRTRules.MultiDimensionalArrayRule, loc, memberId, typeId); return; } // [][]? if (arrTypeSym.ElementType.TypeKind == TypeKind.Array) { Report(WinRTRules.JaggedArrayRule, loc, memberId, typeId); return; } } // NotValidTypes is an array of types that don't exist in Windows Runtime, so can't be passed between functions in Windows Runtime foreach (var typeName in NotValidTypes) { var notValidTypeSym = GetTypeByMetadataName(typeName); if (SymEq(typeSymbol.OriginalDefinition, notValidTypeSym)) { Report(WinRTRules.UnsupportedTypeRule, loc, memberId, typeName, SuggestType(typeName)); return; } } // construct the qualified name for this type string qualifiedName = ""; if (typeSymbol.ContainingNamespace != null && !typeSymbol.ContainingNamespace.IsGlobalNamespace) { // ContainingNamespace for Enumerable is just System, but we need System.Linq which is the ContainingSymbol qualifiedName += typeSymbol.ContainingSymbol + "."; } // instead of TypeName<int>, TypeName`1 qualifiedName += typeSymbol.MetadataName; // GetTypeByMetadataName fails on "System.Linq.Enumerable" & "System.Collections.ObjectModel.ReadOnlyDictionary`2" // Would be fixed by issue #678 on the dotnet/roslyn-sdk repo foreach (var notValidType in WIPNotValidTypes) { if (qualifiedName == notValidType) { Report(WinRTRules.UnsupportedTypeRule, loc, memberId, notValidType, SuggestType(notValidType)); return; } } }
public override async ValueTask <ITypeSymbol> VisitArrayType(IArrayTypeSymbol symbol) { var elementType = await symbol.ElementType.Accept(this).ConfigureAwait(false); if (elementType != null && elementType.Equals(symbol.ElementType)) { return(symbol); } return(_compilation.CreateArrayTypeSymbol(elementType, symbol.Rank)); }
public override ITypeSymbol VisitArrayType(IArrayTypeSymbol symbol) { var elementType = symbol.ElementType.Accept(this); if (elementType != null && elementType.Equals(symbol.ElementType)) { return(symbol); } return(typeGenerator.CreateArrayTypeSymbol(elementType, symbol.Rank)); }
public UdonSharpBehaviourTypeSymbol(IArrayTypeSymbol sourceSymbol, AbstractPhaseContext context) : base(sourceSymbol, context) { if (sourceSymbol.ElementType.TypeKind == TypeKind.Array) { UdonType = (ExternTypeSymbol)context.GetTypeSymbol(SpecialType.System_Object).MakeArrayType(context); } else { UdonType = (ExternTypeSymbol)context.GetTypeSymbol(typeof(Component[])); } }
public ExternTypeSymbol(IArrayTypeSymbol sourceSymbol, AbstractPhaseContext context) : base(sourceSymbol, context) { TryGetSystemType(sourceSymbol, out Type systemType); SystemType = systemType; Type udonType = UdonSharpUtils.UserTypeToUdonType(SystemType); UdonType = (ExternTypeSymbol)(udonType == SystemType ? this : context.GetUdonTypeSymbol(sourceSymbol)); ExternSignature = CompilerUdonInterface.GetUdonTypeName(UdonType); }
public ImportedUdonSharpTypeSymbol(IArrayTypeSymbol sourceSymbol, AbstractPhaseContext context) : base(sourceSymbol, context) { if (sourceSymbol.ElementType.TypeKind == TypeKind.Enum) { UdonType = (ExternTypeSymbol)context.GetTypeSymbol(((INamedTypeSymbol)sourceSymbol.ElementType).EnumUnderlyingType).UdonType.MakeArrayType(context); } else { UdonType = context.GetTypeSymbol(typeof(object[])).UdonType; } }
private static (ITypeSymbol ElementType, string Prefix) ExpandArray(IArrayTypeSymbol array) { var prefix = "Array"; while (array.ElementType is IArrayTypeSymbol subArray) { prefix += "Array"; array = subArray; } return(array.ElementType, prefix); }
public void ReturnsTrue_When_HasNullableReferenceTypeConstraint() { IArrayTypeSymbol type = GetSymbol(); Mock <ITypeParameterSymbol> parameter = new(); parameter.SetupGet(p => p.Name).Returns("T"); parameter.SetupGet(p => p.ConstraintTypes).Returns(ImmutableArray.Create <ITypeSymbol>()); parameter.SetupGet(p => p.HasReferenceTypeConstraint).Returns(true); parameter.SetupGet(p => p.ReferenceTypeConstraintNullableAnnotation).Returns(NullableAnnotation.Annotated); Assert.True(type.IsValidForTypeParameter(parameter.Object)); }
public override TypeSyntax VisitArrayType(IArrayTypeSymbol symbol) { ThrowIfNameOnly(); ITypeSymbol underlyingType = symbol; while (underlyingType is IArrayTypeSymbol innerArray) { underlyingType = innerArray.ElementType; if (underlyingType.NullableAnnotation == NullableAnnotation.Annotated) { // If the inner array we just moved to is also nullable, then // we must terminate the digging now so we produce the syntax for that, // and then append the ranks we passed through at the end. This is because // nullability annotations acts as a "barrier" where we won't reorder array // through. So whereas: // // string[][,] // // is really an array of rank 1 that has an element of rank 2, // // string[]?[,] // // is really an array of rank 2 that has nullable elements of rank 1. break; } } var elementTypeSyntax = underlyingType.GenerateTypeSyntax(); using var _ = ArrayBuilder <ArrayRankSpecifierSyntax> .GetInstance(out var ranks); var arrayType = symbol; while (arrayType != null && !arrayType.Equals(underlyingType)) { ranks.Add(SyntaxFactory.ArrayRankSpecifier( SyntaxFactory.SeparatedList(Enumerable.Repeat <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression(), arrayType.Rank)))); arrayType = arrayType.ElementType as IArrayTypeSymbol; } TypeSyntax arrayTypeSyntax = SyntaxFactory.ArrayType(elementTypeSyntax, ranks.ToSyntaxList()); if (symbol.NullableAnnotation == NullableAnnotation.Annotated) { arrayTypeSyntax = SyntaxFactory.NullableType(arrayTypeSyntax); } return(AddInformationTo(arrayTypeSyntax, symbol)); }
public void ReturnsTrue_When_InheritFromConstraintType_And_ParameterIsConstrainedToNullable() { IArrayTypeSymbol type = GetSymbol(); Mock <ITypeParameterSymbol> parameter = new(); parameter.SetupGet(p => p.Name).Returns("T"); parameter.SetupGet(p => p.ConstraintTypes).Returns(ImmutableArray.Create <ITypeSymbol>(Compilation.CurrentCompilation.GetTypeByMetadataName("System.Collections.IList") !)); parameter.SetupGet(p => p.ConstraintNullableAnnotations).Returns(ImmutableArray.Create(NullableAnnotation.Annotated)); Assert.True(type.IsValidForTypeParameter(parameter.Object)); }
public override void VisitArrayType(IArrayTypeSymbol symbol) { if (TryAddAlias(symbol, builder)) { return; } //See spec section 12.1 for the order of rank specifiers //e.g. int[][,][,,] is stored as // ArrayType // Rank = 1 // ElementType = ArrayType // Rank = 2 // ElementType = ArrayType // Rank = 3 // ElementType = int if (format.CompilerInternalOptions.IncludesOption(SymbolDisplayCompilerInternalOptions.ReverseArrayRankSpecifiers)) { // Ironically, reverse order is simpler - we just have to recurse on the element type and then add a rank specifier. symbol.ElementType.Accept(this); AddArrayRank(symbol); return; } var underlyingNonArrayType = symbol.ElementType; while (underlyingNonArrayType.Kind == SymbolKind.ArrayType) { underlyingNonArrayType = ((IArrayTypeSymbol)underlyingNonArrayType).ElementType; } underlyingNonArrayType.Accept(this.NotFirstVisitor); var arrayType = symbol; while (arrayType != null) { if (!this.isFirstSymbolVisited) { AddCustomModifiersIfRequired(arrayType.CustomModifiers, leadingSpace: true); } AddArrayRank(arrayType); arrayType = arrayType.ElementType as IArrayTypeSymbol; } }
private void AddArrayRank(IArrayTypeSymbol symbol) { bool insertStars = format.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.UseAsterisksInMultiDimensionalArrays); AddPunctuation(SyntaxKind.OpenBracketToken); if (insertStars && symbol.Rank > 1) { AddPunctuation(SyntaxKind.AsteriskToken); } for (int i = 0; i < symbol.Rank - 1; i++) { AddPunctuation(SyntaxKind.CommaToken); if (insertStars) { AddPunctuation(SyntaxKind.AsteriskToken); } } AddPunctuation(SyntaxKind.CloseBracketToken); }
private void AddArrayRank(IArrayTypeSymbol symbol) { bool insertStars = format.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.UseAsterisksInMultiDimensionalArrays); AddPunctuation(SyntaxKind.OpenBracketToken); if (symbol.Rank > 1) { if (insertStars) { AddPunctuation(SyntaxKind.AsteriskToken); } } else { var array = symbol as ArrayTypeSymbol; if ((object)array != null && !array.IsSZArray) { // Always add an asterisk in this case in order to distinguish between SZArray and MDArray. AddPunctuation(SyntaxKind.AsteriskToken); } } for (int i = 0; i < symbol.Rank - 1; i++) { AddPunctuation(SyntaxKind.CommaToken); if (insertStars) { AddPunctuation(SyntaxKind.AsteriskToken); } } AddPunctuation(SyntaxKind.CloseBracketToken); }
public ArrayCreation(IArrayTypeSymbol arrayType, ImmutableArray<IExpression> elementValues, SyntaxNode syntax) { _arrayType = arrayType; this.DimensionSizes = ImmutableArray.Create<IExpression>(new IntegerLiteral(elementValues.Count(), null, syntax)); this.ElementValues = new DimensionInitializer(elementValues); this.Syntax = syntax; }
public override void VisitArrayType(IArrayTypeSymbol arrayTypeSymbol) { arrayTypeSymbol.ElementType.Accept(this); }
public override void VisitArrayType(IArrayTypeSymbol symbol) { base.VisitArrayType(symbol); }
private bool ArrayTypesAreEquivalent(IArrayTypeSymbol x, IArrayTypeSymbol y, Dictionary<INamedTypeSymbol, INamedTypeSymbol> equivalentTypesWithDifferingAssemblies) { return x.Rank == y.Rank && AreEquivalent(x.ElementType, y.ElementType, equivalentTypesWithDifferingAssemblies); }
private void Visit(IArrayTypeSymbol type) { Visit(type.ElementType); builder.Append("["); for (int i = 1; i <= type.Rank; i++) builder.Append(","); builder.Append("]"); }
private static bool AtLeastOneExactTypeMatch(SemanticModel semanticModel, ArrayCreationExpressionSyntax arrayCreation, IArrayTypeSymbol arrayType) { return arrayCreation.Initializer.Initializers.Any(initializer => arrayType.ElementType.Equals(semanticModel.GetTypeInfo(initializer).Type)); }
public ArrayParameterHintingData (IArrayTypeSymbol arrayType) : base (arrayType) { this.arrayType = arrayType; }
private static async Task<GraphNodeId> GetPartialForArrayTypeAsync(IArrayTypeSymbol arrayType, GraphNodeIdName nodeName, Solution solution, CancellationToken cancellationToken) { var partials = new List<GraphNodeId>(); var underlyingType = ChaseToUnderlyingType(arrayType); if (underlyingType.TypeKind == TypeKind.Dynamic) { partials.Add(GraphNodeId.GetPartial(CodeQualifiedName.Name, "Object")); } else if (underlyingType.TypeKind != TypeKind.TypeParameter) { partials.Add(GraphNodeId.GetPartial(CodeQualifiedName.Name, underlyingType.Name)); } partials.Add(GraphNodeId.GetPartial(CodeQualifiedName.ArrayRank, arrayType.Rank.ToString())); partials.Add(await GetPartialForTypeAsync(arrayType.ElementType, CodeGraphNodeIdName.ParentType, solution, cancellationToken).ConfigureAwait(false)); return GraphNodeId.GetPartial(nodeName, MakeCollectionIfNecessary(false, partials.ToArray())); }
public string GetArrayIndexerMarkup (IArrayTypeSymbol arrayType) { if (arrayType == null) throw new ArgumentNullException ("arrayType"); var result = new StringBuilder (); result.Append (GetTypeReferenceString (arrayType.ElementType)); if (BreakLineAfterReturnType) { result.AppendLine (); } else { result.Append (" "); } result.Append (Highlight ("this", colorStyle.KeywordAccessors)); result.Append ("["); for (int i = 0; i < arrayType.Rank; i++) { if (i > 0) result.Append (", "); var doHighightParameter = i == HighlightParameter; if (doHighightParameter) result.Append ("<u>"); result.Append (Highlight ("int ", colorStyle.KeywordTypes)); result.Append (arrayType.Rank == 1 ? "index" : "i" + (i + 1)); if (doHighightParameter) result.Append ("</u>"); } result.Append ("]"); result.Append (" {"); result.Append (Highlight (" get", colorStyle.KeywordProperty) + ";"); result.Append (Highlight (" set", colorStyle.KeywordProperty) + ";"); result.Append (" }"); return result.ToString (); }
public override void VisitArrayType(IArrayTypeSymbol symbol) { symbol.ElementType.Accept(this); if (symbol.Rank == 1) { ReferenceItem.Parts[SyntaxLanguage.CSharp].Add(new LinkItem { DisplayName = "[]", DisplayQualifiedNames = "[]", }); } else { ReferenceItem.Parts[SyntaxLanguage.CSharp].Add(new LinkItem { DisplayName = "[" + new string(',', symbol.Rank - 1) + "]", DisplayQualifiedNames = "[" + new string(',', symbol.Rank - 1) + "]", }); } }
public override void VisitArrayType(IArrayTypeSymbol symbol) { symbol.ElementType.Accept(this); if (symbol.Rank == 1) { Append("()"); } else { Append("("); for (int i = 1; i < symbol.Rank; i++) { Append(","); } Append(")"); } }
public static void Create(IArrayTypeSymbol symbol, SymbolKeyWriter visitor) { visitor.WriteSymbolKey(symbol.ElementType); visitor.WriteInteger(symbol.Rank); }
public JsInvocationExpression MakeArray(JsExpression array, IArrayTypeSymbol arrayType) { if (arrayType.ElementType.Equals(Context.Instance.Int32)) array = Js.New(Js.Reference("Int32Array"), array); else if (arrayType.ElementType.Equals(Context.Instance.Int16)) array = Js.New(Js.Reference("Int16Array"), array); else if (arrayType.ElementType.Equals(Context.Instance.Byte)) array = Js.New(Js.Reference("Uint8Array"), array); else if (arrayType.ElementType.Equals(Context.Instance.SByte)) array = Js.New(Js.Reference("Int8Array"), array); else if (arrayType.ElementType.Equals(Context.Instance.Single)) array = Js.New(Js.Reference("Float32Array"), array); else if (arrayType.ElementType.Equals(Context.Instance.Double)) array = Js.New(Js.Reference("Float64Array"), array); return Js.Reference(SpecialNames.InitializeArray).Invoke( array, Type(arrayType.ElementType)); }
public virtual void VisitArrayType(IArrayTypeSymbol symbol) { DefaultVisit(symbol); }
public sealed override void VisitArrayType(IArrayTypeSymbol symbol) { Visit(symbol.ElementType); }
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); }); }
public JsInvocationExpression Array(IArrayTypeSymbol arrayType, params JsExpression[] elements) { return MakeArray(Js.Array(elements), arrayType); }