Exemple #1
0
        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);
            });
        }
Exemple #2
0
        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));
            }
        }
Exemple #3
0
        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);
            }
        }
Exemple #4
0
        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));
            }
        }