public static string GetParameterListAsString(ImmutableArray <IParameterSymbol> parameters, bool includeTypes = true, ITypeSymbol iface = null, bool writebraces = true)
{
var writer = new TempWriter(); // Temp Writer
if (writebraces)
{
writer.Write("(");
}
var firstParam = true;
foreach (var parameter in parameters)
{
var refKeyword = "";
if (parameter.RefKind == RefKind.Ref)
{
refKeyword = " ref ";
}
if (parameter.RefKind == RefKind.Out)
{
refKeyword = " out ";
}
// if (parameter.RefKind==RefKind.None) //????
// refKeyword = " in ";
bool isRef = parameter.RefKind == RefKind.Ref || parameter.RefKind == RefKind.Out;// parameter.Modifiers.Any(SyntaxKind.OutKeyword) ||
// parameter.Modifiers.Any(SyntaxKind.RefKeyword);
// || parameter.Modifiers.Any (SyntaxKind.InKeyword);
if (firstParam)
{
firstParam = false;
}
else
{
writer.Write(", ");
}
var isParams = parameter.IsParams;//.Any(SyntaxKind.ParamsKeyword);
//if (!isParams)
{
var s = refKeyword + TypeProcessor.ConvertType(parameter.Type) + " ";
if (includeTypes)
{
writer.Write(s);
}
}
/* else //Framework depends too much on managed arrays even for params
* {
* var type = (TypeProcessor.GetTypeInfo(parameter.Type).Type ?? TypeProcessor.GetTypeInfo(parameter.Type).ConvertedType) as IArrayTypeSymbol;
* var s = refKeyword + TypeProcessor.ConvertType(type.ElementType) + "[]";
*
* if (includeTypes)
* writer.Write(s);
*
* }*/
writer.Write(WriteIdentifierName.TransformIdentifier(parameter.Name));
if (!parameter.HasExplicitDefaultValue)
{
continue;
}
writer.Write(" = ");
if (parameter.ExplicitDefaultValue is SyntaxNode)
{
Core.Write(writer, (SyntaxNode)(parameter.ExplicitDefaultValue)); //TODO ??
}
else
{
if (parameter.ExplicitDefaultValue is string)
{
writer.Write("_S(\"" + parameter.ExplicitDefaultValue.ToString() + "\")");
}
else
{
writer.Write(parameter.ExplicitDefaultValue.ToString());
}
}
}
if (iface != null)
{
if (firstParam)
{
firstParam = false;
}
else
{
writer.Write(", ");
}
writer.Write(TypeProcessor.ConvertType(iface) + " __j = null");
}
if (writebraces)
{
writer.Write(")");
}
return(writer.ToString());
}
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));
}
}
public static string GetParameterListAsString(SeparatedSyntaxList <ParameterSyntax> parameters, bool includeTypes = true, ITypeSymbol iface = null, bool writebraces = true, ITypeSymbol genericClass = null)
{
var writer = new TempWriter(); // Temp Writer
if (writebraces)
{
writer.Write("(");
}
var firstParam = true;
foreach (var parameter in parameters)
{
var refKeyword = "";
if (parameter.Modifiers.Any(SyntaxKind.RefKeyword))
{
refKeyword = " ref ";
}
if (parameter.Modifiers.Any(SyntaxKind.OutKeyword))
{
refKeyword = " out ";
}
if (parameter.Modifiers.Any(SyntaxKind.InKeyword))
{
refKeyword = " in ";
}
bool isRef = parameter.Modifiers.Any(SyntaxKind.OutKeyword) ||
parameter.Modifiers.Any(SyntaxKind.RefKeyword);
// || parameter.Modifiers.Any (SyntaxKind.InKeyword);
if (firstParam)
{
firstParam = false;
}
else
{
writer.Write(", ");
}
var isParams = parameter.Modifiers.Any(SyntaxKind.ParamsKeyword);
//if (!isParams)
{
var s = refKeyword + TypeProcessor.ConvertType(parameter.Type) + " ";
if (includeTypes)
{
writer.Write(s);
}
}
/* else //Framework depends too much on managed arrays even for params
* {
* var type = (TypeProcessor.GetTypeInfo(parameter.Type).Type ?? TypeProcessor.GetTypeInfo(parameter.Type).ConvertedType) as IArrayTypeSymbol;
* var s = refKeyword + TypeProcessor.ConvertType(type.ElementType) + "[]";
*
* if (includeTypes)
* writer.Write(s);
*
* }*/
writer.Write(WriteIdentifierName.TransformIdentifier(parameter.Identifier.Text));
if (parameter.Default == null)
{
continue;
}
writer.Write(" = ");
Core.Write(writer, parameter.Default.Value);
}
if (genericClass != null)
{
writer.Write(TypeProcessor.ConvertType(genericClass) + " __obj");
if (firstParam)
{
firstParam = false;
}
else
{
writer.Write(", ");
}
}
else
if (iface != null)
{
if (firstParam)
{
firstParam = false;
}
else
{
writer.Write(", ");
}
writer.Write(TypeProcessor.ConvertType(iface) + " __j = null");
}
if (writebraces)
{
writer.Write(")");
}
return(writer.ToString());
}
