private static void ProcessAnonymousTypes() { _compilation.SyntaxTrees .SelectMany(o => o.GetRoot().DescendantNodes().OfType <AnonymousObjectCreationExpressionSyntax>()) .Select(o => new { Syntax = o, Name = WriteAnonymousObjectCreationExpression.TypeName(o) }) .GroupBy(o => o.Name) .Parallel(o => { Context.Instance = new Context { TypeName = o.Key, }; WriteAnonymousObjectCreationExpression.WriteAnonymousType(o.First().Syntax); }); }
private static void Factory(OutputWriter writer, SyntaxNode node, bool isConst) { if (node is ConstructorInitializerSyntax) { WriteConstructorInitializer.Go(writer, node.As <ConstructorInitializerSyntax>()); } else if (node is CheckedExpressionSyntax) { WriteChecked.Go(writer, node.As <CheckedExpressionSyntax>()); } else if (node is CheckedStatementSyntax) { WriteChecked.Go(writer, node.As <CheckedStatementSyntax>()); } else if (node is UnsafeStatementSyntax) { WriteUnsafeStatement.Go(writer, node.As <UnsafeStatementSyntax>()); } else if (node is InitializerExpressionSyntax) { WriteInitializer.Go(writer, node.As <InitializerExpressionSyntax>()); } else if (node is GotoStatementSyntax) { WriteGoto.Go(writer, node.As <GotoStatementSyntax>()); } else if (node is CaseSwitchLabelSyntax) { WriteLabel.Go(writer, node.As <CaseSwitchLabelSyntax>()); } else if (node is LabeledStatementSyntax) { WriteLabel.Go(writer, node.As <LabeledStatementSyntax>()); } else if (node is OperatorDeclarationSyntax) { WriteOperatorDeclaration.Go(writer, node.As <OperatorDeclarationSyntax>()); } else if (node is MethodDeclarationSyntax) { WriteMethod.Go(writer, node.As <MethodDeclarationSyntax>()); } else if (node is PropertyDeclarationSyntax) { WriteProperty.Go(writer, node.As <PropertyDeclarationSyntax>()); } else if (node is EventDeclarationSyntax) { WriteEvent.Go(writer, node.As <EventDeclarationSyntax>()); } else if (node is FieldDeclarationSyntax) { WriteField.Go(writer, node.As <FieldDeclarationSyntax>()); } else if (node is EventFieldDeclarationSyntax) { WriteField.Go(writer, node.As <EventFieldDeclarationSyntax>()); } else if (node is ConstructorDeclarationSyntax) { WriteConstructorBody.Go(writer, node.As <ConstructorDeclarationSyntax>()); } else if (node is ExpressionStatementSyntax) { WriteStatement(writer, node.As <ExpressionStatementSyntax>()); } else if (node is FixedStatementSyntax) { WriteFixedStatement(writer, node.As <FixedStatementSyntax>()); } else if (node is LocalDeclarationStatementSyntax) { WriteLocalDeclaration.Go(writer, node.As <LocalDeclarationStatementSyntax>()); } else if (node is VariableDeclarationSyntax) { WriteVariableDeclaration.Go(writer, node.As <VariableDeclarationSyntax>()); } else if (node is BlockSyntax) { WriteBlock(writer, node.As <BlockSyntax>()); } else if (node is InvocationExpressionSyntax) { WriteInvocationExpression.Go(writer, node.As <InvocationExpressionSyntax>()); } else if (node is LiteralExpressionSyntax) { WriteLiteralExpression.Go(writer, node.As <LiteralExpressionSyntax>(), isConst); } else if (node is IdentifierNameSyntax) { WriteIdentifierName.Go(writer, node.As <IdentifierNameSyntax>()); } else if (node is ImplicitArrayCreationExpressionSyntax) { WriteArrayCreationExpression.Go(writer, node.As <ImplicitArrayCreationExpressionSyntax>()); } else if (node is ArrayCreationExpressionSyntax) { WriteArrayCreationExpression.Go(writer, node.As <ArrayCreationExpressionSyntax>()); } else if (node is MemberAccessExpressionSyntax) { WriteMemberAccessExpression.Go(writer, node.As <MemberAccessExpressionSyntax>()); } else if (node is ParenthesizedLambdaExpressionSyntax) { WriteLambdaExpression.Go(writer, node.As <ParenthesizedLambdaExpressionSyntax>()); } else if (node is SimpleLambdaExpressionSyntax) { WriteLambdaExpression.Go(writer, node.As <SimpleLambdaExpressionSyntax>()); } else if (node is AnonymousMethodExpressionSyntax) { WriteLambdaExpression.Go(writer, node.As <AnonymousMethodExpressionSyntax>()); } else if (node is ReturnStatementSyntax) { WriteReturnStatement.Go(writer, node.As <ReturnStatementSyntax>()); } else if (node is ObjectCreationExpressionSyntax) { WriteObjectCreationExpression.Go(writer, node.As <ObjectCreationExpressionSyntax>()); } else if (node is ElementAccessExpressionSyntax) { WriteElementAccessExpression.Go(writer, node.As <ElementAccessExpressionSyntax>()); } else if (node is ForEachStatementSyntax) { WriteForEachStatement.Go(writer, node.As <ForEachStatementSyntax>()); } else if (node is IfStatementSyntax) { WriteIfStatement.Go(writer, node.As <IfStatementSyntax>()); } else if (node is BinaryExpressionSyntax) { WriteBinaryExpression.Go(writer, node.As <BinaryExpressionSyntax>()); } else if (node is AssignmentExpressionSyntax) { WriteAssignmentExpression.Go(writer, node.As <AssignmentExpressionSyntax>()); } else if (node is ConditionalExpressionSyntax) { WriteConditionalExpression.Go(writer, node.As <ConditionalExpressionSyntax>()); } else if (node is BaseExpressionSyntax) { WriteBaseExpression.Go(writer, node.As <BaseExpressionSyntax>()); } else if (node is ThisExpressionSyntax) { WriteThisExpression.Go(writer, node.As <ThisExpressionSyntax>()); } else if (node is CastExpressionSyntax) { WriteCastExpression.Go(writer, node.As <CastExpressionSyntax>()); } else if (node is ThrowStatementSyntax) { WriteThrowStatement.Go(writer, node.As <ThrowStatementSyntax>()); } else if (node is EqualsValueClauseSyntax) { WriteEqualsValueClause.Go(writer, node.As <EqualsValueClauseSyntax>()); } else if (node is ForStatementSyntax) { WriteForStatement.Go(writer, node.As <ForStatementSyntax>()); } else if (node is WhileStatementSyntax) { WriteWhileStatement.Go(writer, node.As <WhileStatementSyntax>()); } else if (node is BreakStatementSyntax) { WriteBreakStatement.Go(writer, node.As <BreakStatementSyntax>()); } else if (node is ContinueStatementSyntax) { WriteContinueStatement.Go(writer, node.As <ContinueStatementSyntax>()); } else if (node is DoStatementSyntax) { WriteDoStatement.Go(writer, node.As <DoStatementSyntax>()); } else if (node is SwitchStatementSyntax) { WriteSwitchStatement.Go(writer, node.As <SwitchStatementSyntax>()); } else if (node is TryStatementSyntax) { WriteTryStatement.Go(writer, node.As <TryStatementSyntax>()); } else if (node is UsingStatementSyntax) { WriteUsingStatement.Go(writer, node.As <UsingStatementSyntax>()); } else if (node is ParenthesizedExpressionSyntax) { WriteParenthesizedExpression.Go(writer, node.As <ParenthesizedExpressionSyntax>()); } else if (node is LockStatementSyntax) { WriteLockStatement.Go(writer, node.As <LockStatementSyntax>()); } else if (node is TypeOfExpressionSyntax) { WriteTypeOfExpression.Go(writer, node.As <TypeOfExpressionSyntax>()); } else if (node is AnonymousObjectCreationExpressionSyntax) { WriteAnonymousObjectCreationExpression.Go(writer, node.As <AnonymousObjectCreationExpressionSyntax>()); } else if (node is EmptyStatementSyntax) { return; //ignore empty statements } else if (node is DelegateDeclarationSyntax) { return; //don't write delegates - TypeProcessor converts them to function types directly } else if (node is DefaultExpressionSyntax) { WriteDefaultExpression.Go(writer, node.As <DefaultExpressionSyntax>()); } else if (node is GenericNameSyntax) { WriteGenericName.Go(writer, node.As <GenericNameSyntax>()); } else if (node is ConversionOperatorDeclarationSyntax) { WriteConversionOperatorDeclaration.Go(writer, node.As <ConversionOperatorDeclarationSyntax>()); } else if (node is PrefixUnaryExpressionSyntax) { WriteUnaryExpression.WritePrefix(writer, node.As <PrefixUnaryExpressionSyntax>()); } else if (node is PostfixUnaryExpressionSyntax) { WriteUnaryExpression.WritePostfix(writer, node.As <PostfixUnaryExpressionSyntax>()); } else if (node is SizeOfExpressionSyntax) { WriteSizeOfExpression.Go(writer, node.As <SizeOfExpressionSyntax>()); } else if (node is DestructorDeclarationSyntax) { WriteDestructorBody.WriteDestructor(writer, node.As <DestructorDeclarationSyntax>()); } else if (node is IndexerDeclarationSyntax) { WriteIndexer.Go(writer, node.As <IndexerDeclarationSyntax>()); } else if (node is StackAllocArrayCreationExpressionSyntax) { WriteStackArrayCreation.Go(writer, node.As <StackAllocArrayCreationExpressionSyntax>()); } // writer.Write(node.ToFullString() + "//TODO: StackAlloc not supported yet"); else if (node is YieldStatementSyntax) { WriteYieldStatement.Go(writer, node.As <YieldStatementSyntax>()); } else { throw new NotImplementedException(node.GetType().Name + " is not supported. " + Utility.Descriptor(node)); } }
private static string ConvertTypeUncached(ITypeSymbol typeSymbol, bool localize) { if (typeSymbol.IsAnonymousType) { return(WriteAnonymousObjectCreationExpression.TypeName(typeSymbol.As <INamedTypeSymbol>())); } var array = typeSymbol as IArrayTypeSymbol; var ptr = array != null && (array.ElementType.IsValueType == false); if (array != null) { var typeString = TryConvertType(array.ElementType, localize); if (localize) { var name = Context.Instance.UsingDeclarations.FirstOrDefault( k => typeString.StartsWith(k.Name.ToFullString() + ".Namespace.", StringComparison.Ordinal)); if (name != null) { typeString = typeString.RemoveFromStartOfString(name.Name.ToFullString() + ".Namespace."); } } //if (array.Rank == 1) // Jagged / Single return("Array_T!(" + typeString + ")"); // else // { // return "Array_T!(" + typeString + Enumerable.Range (0, array.Rank-1).Select (l => "[]").Aggregate ((a, b) => a + b).ToString () +")"; // // } } if (typeSymbol.TypeKind == TypeKind.PointerType) { var pointer = typeSymbol as IPointerTypeSymbol; return(ConvertType(pointer.PointedAtType) + "*"); } var typeInfoStr = typeSymbol.ToString(); var named = typeSymbol as INamedTypeSymbol; if (typeSymbol.TypeKind == TypeKind.TypeParameter) { return(typeSymbol.Name); } // if (typeSymbol.TypeKind == TypeKind.Delegate) { // var dlg = named.DelegateInvokeMethod.As<IMethodSymbol> (); // if (dlg.Parameters.Length == 0) // return "() => " + TryConvertType (dlg.ReturnType); // else // return "(" + string.Join (", ", dlg.Parameters.ToList ().Select (o => TryConvertType (o.Type))) + ") => " + TryConvertType (dlg.ReturnType); // } // if (typeSymbol.TypeKind == TypeKind.Enum) // return "int"; //enums are always ints if (named.ContainingNamespace.ToString() == "System" && named.Name == "Exception") { return("System.Namespace.NException"); } if (named != null && named.Name == "Nullable" && named.ContainingNamespace.ToString() == "System") { //Nullable types var convertedType = TryConvertType(named.TypeArguments.Single()); switch (convertedType) { case "Int": return("int"); case "Boolean": return("bool"); case "Byte": return("byte"); case "Short": return("short"); case "Float": return("float"); case "Double": return("double"); case "Char": return("char"); case "Long": return("long"); default: return(convertedType); } } var typeStr = GenericTypeName(typeSymbol); if (named != null && named.IsGenericType && !named.IsUnboundGenericType && TypeArguments(named).Any()) { return(TryConvertType(named.ConstructUnboundGenericType()) + "!(" + string.Join(", ", TypeArguments(named).Select(o => TryConvertType(o))) + ")"); } switch (typeStr) { case "System.Namespace.Void": return("void"); case "System.Namespace.Boolean": return("bool"); case "System.Object": case "System.Namespace.Object": return("NObject"); case "System.Namespace.UInt64": return("ulong"); case "System.Namespace.Double": return("double"); case "System.Namespace.Single": return("float"); case "System.Namespace.String": return("String"); case "System.Namespace.Int32": return("int"); case "System.Namespace.UInt16": return("ushort"); case "System.Namespace.Int64": return("long"); case "System.Namespace.UInt32": return("long"); // Looks like d's uint32 is smaller than C#'s case "System.Namespace.Byte": return("byte"); case "System.Namespace.Int16": return("short"); case "System.Namespace.Char": return("char"); case "System.Namespace.Array": return("Array_T"); //All template (generic) classes have atleast one "_T" appended default: if (named != null) { return(typeSymbol.ContainingNamespace.FullNameWithDot() + WriteType.TypeName(named)); } //This type does not get translated and gets used as-is return(typeSymbol.ContainingNamespace.FullNameWithDot() + typeSymbol.Name); } }
private static string ConvertTypeUncached(ITypeSymbol typeSymbol) { if (typeSymbol.IsAnonymousType) { return(WriteAnonymousObjectCreationExpression.TypeName(typeSymbol.As <INamedTypeSymbol>())); } var array = typeSymbol as IArrayTypeSymbol; if (array != null) { var typeString = TryConvertType(array.ElementType, false); // if (localize) // { // var name = // Context.Instance.UsingDeclarations.FirstOrDefault( // k => typeString.StartsWith(k.Name.ToFullString() + ".Namespace.", StringComparison.Ordinal)); // // if (name != null) // typeString = typeString.RemoveFromStartOfString(name.Name.ToFullString() + ".Namespace."); // } return("Array_T!(" + typeString + ")"); } if (typeSymbol.TypeKind == TypeKind.PointerType) { var pointer = typeSymbol as IPointerTypeSymbol; return(ConvertType(pointer.PointedAtType) + "*"); } var typeInfoStr = typeSymbol.ToString(); var named = typeSymbol as INamedTypeSymbol; if (typeSymbol.TypeKind == TypeKind.TypeParameter) { return(WriteIdentifierName.TransformIdentifier(typeSymbol.Name, typeSymbol)); } if (named != null && (named.ContainingNamespace.ToString() == "System" && named.Name == "Exception")) { return("System.Namespace.NException"); } //TODO: Add explicit support for Nullable if (named != null && (named.Name == "Nullable" && named.ContainingNamespace.ToString() == "System")) { //Nullable types if (named.TypeArguments.Any()) { string convertedType = ""; if (named.TypeArguments.FirstOrDefault() is IErrorTypeSymbol) { //unbound generic convertedType = "__UNBOUND"; } else { convertedType = TryConvertType(named.TypeArguments.FirstOrDefault(), false); } return("Nullable__G!(" + convertedType + ")"); } } var typeStr = GenericTypeName(typeSymbol); if (named != null && named.IsGenericType) { if (!named.IsUnboundGenericType && TypeArguments(named).Any()) { return(GetFullGenericName(named)); } else { return(GetFullGenericName(named.OriginalDefinition)); } } switch (typeStr) { case "System.Namespace.Void": return("void"); case "System.Namespace.Boolean": return("bool"); case "System.Object": case "System.Namespace.Object": return("NObject"); case "System.Namespace.UInt64": return("ulong"); case "System.Namespace.Double": return("double"); case "System.Namespace.Single": return("float"); case "System.Namespace.String": return("String"); case "System.Namespace.Int32": return("int"); case "System.Namespace.UInt16": return("ushort"); case "System.Namespace.Int64": return("long"); case "System.Namespace.UInt32": return("uint"); // /TODO: Looks like d's uint32 is smaller than C#'s case "System.Namespace.Byte": return("ubyte"); case "System.Namespace.SByte": return("byte"); case "System.Namespace.Int16": return("short"); case "System.Namespace.Char": return("wchar"); case "System.Namespace.Array": return("Array"); //All template (generic) classes have atleast one "_T" appended default: if (named != null) { return(typeSymbol.ContainingNamespace.FullNameWithDot(true, false) + WriteType.TypeName(named)); } //This type does not get translated and gets used as-is return(typeSymbol.ContainingNamespace.FullNameWithDot(true, false) + WriteIdentifierName.TransformIdentifier(typeSymbol.Name)); } }