private static List <FieldDeclarationSyntax> SortFields(List <FieldDeclarationSyntax> fields)
{
if (fields.Count == 0)
{
return(fields);
}
var dependencies =
fields.ToDictionary(
o => TypeProcessor.GetDeclaredSymbol(o.Declaration.Variables.First()).As <IFieldSymbol>(),
o => new { Syntax = o, Dependicies = new List <IFieldSymbol>() });
foreach (var dep in dependencies)
{
foreach (
var fieldDepend in
dep.Value.Syntax.DescendantNodes()
.OfType <ExpressionSyntax>()
.Select(o => TypeProcessor.GetSymbolInfo(o).Symbol)
.OfType <IFieldSymbol>())
{
if (dependencies.ContainsKey(fieldDepend))
{
dep.Value.Dependicies.Add(fieldDepend);
}
}
}
var ret = new List <FieldDeclarationSyntax>();
var symbolsAdded = new HashSet <IFieldSymbol>();
while (dependencies.Count > 0)
{
foreach (var dep in dependencies.ToList())
{
for (int i = 0; i < dep.Value.Dependicies.Count; i++)
{
if (symbolsAdded.Contains(dep.Value.Dependicies[i]))
{
dep.Value.Dependicies.RemoveAt(i--);
}
}
if (dep.Value.Dependicies.Count == 0)
{
ret.Add(dep.Value.Syntax);
symbolsAdded.Add(dep.Key);
dependencies.Remove(dep.Key);
}
}
}
return(ret);
}
public static void WriteParameterList(OutputWriter writer, ParameterListSyntax list)
{
writer.Write("(");
var firstParam = true;
foreach (var parameter in list.Parameters)
{
bool isRef = parameter.Modifiers.Any(SyntaxKind.OutKeyword) ||
parameter.Modifiers.Any(SyntaxKind.RefKeyword);
if (firstParam)
{
firstParam = false;
}
else
{
writer.Write(", ");
}
var localSymbol = TypeProcessor.GetTypeInfo(parameter.Type);
var ptr = (localSymbol.Type != null &&
!(localSymbol.Type.IsValueType || localSymbol.Type.TypeKind == TypeKind.TypeParameter));
if (!isRef)
{
// var s = TypeProcessor.ConvertType(parameter.Type) + " " + ptr;
var s = TypeProcessor.ConvertType(parameter.Type) + " ";
writer.Write(s);
}
else
{
// var s = "" + TypeProcessor.ConvertType(parameter.Type) + ptr + "& ";
var s = " ref " + TypeProcessor.ConvertType(parameter.Type) + " ";
writer.Write(s);
Program.RefOutSymbols.TryAdd(TypeProcessor.GetDeclaredSymbol(parameter), null);
}
writer.Write(WriteIdentifierName.TransformIdentifier(parameter.Identifier.ValueText));
if (parameter.Default != null)
{
writer.Write(" = ");
Core.Write(writer, parameter.Default.Value);
}
}
writer.Write(") ");
}
private static bool ShouldUseOverrideKeyword(MemberDeclarationSyntax member, bool isInterface)
{
ISymbol symbol = TypeProcessor.GetDeclaredSymbol(member);
if (symbol is IMethodSymbol)
{
if ((symbol as IMethodSymbol).IsGenericMethod)
{
return(false);
}
}
if (symbol.ContainingType.TypeKind == TypeKind.Struct ||
symbol.ContainingType.TypeKind == TypeKind.Interface)
{
return(false);
// Structs dont have a base class to override (maybe opEquals) ... but that will be handled separately
//Interfaces are contracts, so no overriding here// maybe we should compare the methods
}
if (member.GetModifiers().Any(SyntaxKind.OverrideKeyword) && !isInterface)
{
return(true);
}
if (member.GetModifiers().Any(SyntaxKind.StaticKeyword))
{
return(false);
}
// if (method.Modifiers.Any(SyntaxKind.NewKeyword))
// return symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any(k=>k.IsAbstract || k.IsVirtual);
if (member.GetModifiers().Any(SyntaxKind.PartialKeyword))
{
//partial methods seem exempt from C#'s normal override keyword requirement, so we have to check manually to see if it exists in a base class
return(symbol.ContainingType.BaseType.GetMembers(symbol.Name).Any());
}
return(member.GetModifiers().Any(SyntaxKind.OverrideKeyword));
}
public static void Go(OutputWriter writer, VariableDeclarationSyntax declaration)
{
foreach (var variable in declaration.Variables)
{
ISymbol symbol = TypeProcessor.GetDeclaredSymbol(variable);
var isRef = false; //UsedAsRef(variable, symbol);
writer.WriteIndent();
// writer.Write("var ");
// if (isRef) //Not needed c++ can passby ref
// {
//
// var typeStr = TypeProcessor.ConvertType(declaration.Declaration.Type);
//
// var localSymbol = symbol as ILocalSymbol;
// var ptr = localSymbol != null && !localSymbol.Type.IsValueType?"*" : "";
// writer.Write("gc::gc_ptr < " + typeStr+ ptr + " >");
// writer.Write("" + typeStr + ptr + "");
//
// writer.Write(" ");
// writer.Write(WriteIdentifierName.TransformIdentifier(variable.Identifier.Text));
//
// Program.RefOutSymbols.TryAdd(symbol, null);
//
// writer.Write(" = std::make_shared < ");
// writer.Write(typeStr + ptr);
// writer.Write(" >(");
//
// WriteInitializer(writer, declaration, variable);
//
// writer.Write(")");
// }
// else
{
var lsymbol = symbol as ILocalSymbol;
if (lsymbol != null && lsymbol.Type.IsValueType == false)
{
writer.Write(" ");
// Ideally Escape analysis should take care of this, but for now all value types are on heap and ref types on stack
}
writer.Write(TypeProcessor.ConvertType(declaration.Type));
if (lsymbol != null && lsymbol.Type.IsValueType == false)
{
writer.Write(" ");
}
writer.Write(" ");
writer.Write(WriteIdentifierName.TransformIdentifier(variable.Identifier.Text));
writer.Write(" = ");
WriteInitializer(writer, declaration, variable);
}
writer.Write(";\r\n");
}
}
public static void Go(OutputWriter writer, EventDeclarationSyntax property)
{
writer.WriteLine("\r\n");
var rEf = ""; //" ref ";// ref should be used based on analysis, is the return type a single var or not
//TODO, doesnt ref make things slower ?, though it makes proprties behave as in c#
var isInterface = property.Parent is InterfaceDeclarationSyntax;
var add =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.AddKeyword);
var remove =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.RemoveKeyword);
var eventSymbol = TypeProcessor.GetDeclaredSymbol(property);
var methodSymbol =
(TypeProcessor.GetDeclaredSymbol(add) ?? TypeProcessor.GetDeclaredSymbol(remove)) as IMethodSymbol;
ITypeSymbol interfaceImplemented;
ISymbol[] proxies;
;
var methodName = WriteIdentifierName.TransformIdentifier(MemberUtilities.GetMethodName(eventSymbol, ref isInterface, out interfaceImplemented, out proxies));
Action <AccessorDeclarationSyntax, bool> writeRegion = (region, get) =>
{
writer.WriteIndent();
// if (property.Modifiers.Any(SyntaxKind.PrivateKeyword))
// writer.HeaderWriter.Write("private:\n");
//
// if (property.Modifiers.Any(SyntaxKind.PublicKeyword) || property.Modifiers.Any(SyntaxKind.InternalKeyword))
// writer.HeaderWriter.Write("public ");
var typeinfo = TypeProcessor.GetTypeInfo(property.Type);
var isPtr = "";
var typeString = TypeProcessor.ConvertType(property.Type) + isPtr + " ";
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
{
writer.Write(" abstract ");
}
if (property.Modifiers.Any(SyntaxKind.OverrideKeyword))
{
writer.Write(" override ");
}
writer.Write("void ");
writer.Write(
(get ? "Add_" : "Remove_") + methodName + "( " + typeString + " value");
if (isInterface)
{
writer.WriteLine(" , " + TypeProcessor.ConvertType(interfaceImplemented) + " __ij = null");
}
writer.Write(" )");
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
{
writer.Write(";\r\n");
}
else
{
// writer.Write(";\r\n");
writer.OpenBrace();
// writer.Write(" =\r\n");
Core.WriteBlock(writer, region.Body.As <BlockSyntax>());
writer.CloseBrace();
writer.Write("\r\n");
}
};
if (add == null && remove == null)
{
throw new Exception("Event must have both a add and remove");
}
{
var name = WriteIdentifierName.TransformIdentifier(property.Identifier.Text);
var type = property.Type;
var typeinfo = TypeProcessor.GetTypeInfo(type);
var modifiers = property.Modifiers;
var typeString = TypeProcessor.ConvertType(type) + " ";
var isStatic = false;
//Handle Auto Properties
var accessors = property.AccessorList.Accessors; //.Where(o=>o.Body==null);
var accessString = "";
if (modifiers.Any(SyntaxKind.PrivateKeyword))
{
accessString += (" private ");
}
if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
accessString += (" public ");
}
var IsStatic = "";
if (modifiers.Any(SyntaxKind.StaticKeyword))
{
isStatic = true;
IsStatic = accessString += " static ";
// writer.HeaderWriter.Write("static ");
}
var fieldName = "__evt__" + name + (interfaceImplemented != null?TypeProcessor.ConvertType(interfaceImplemented)
.Replace("(", "_").Replace("!", "_").Replace(")", "_").Replace(".", "_") :"");
if (!(property.Parent is InterfaceDeclarationSyntax))
{
if (!isStatic)
{
writer.Write("private " + "__Event!(" + typeString + ") " + fieldName + ";\r\n");
// Internal Field used for event
writer.Write(accessString);
writer.WriteLine("__Event!(" + typeString + ") " + name + "(" + (interfaceImplemented != null ? (TypeProcessor.ConvertType(interfaceImplemented) + " __ij = null") :"") + ") @property");
writer.OpenBrace();
writer.WriteLine("if (" + fieldName + " is null)");
writer.OpenBrace();
writer.Write(fieldName + " = new " + "__Event!(" + typeString + ")(new Action__G!(" +
typeString +
")(&Add_" + name + "),new Action__G!(" + typeString + ")(&Remove_" + name + ") );");
writer.CloseBrace();
writer.Write("return " + fieldName + ";");
writer.CloseBrace();
}
else
{
writer.Write(IsStatic);
writer.Write("__Event!(" + typeString + ") " + name + ";\r\n");
}
}
//
var isOverride = property.Modifiers.Any(SyntaxKind.NewKeyword) ||
property.Modifiers.Any(SyntaxKind.OverrideKeyword)
? " override "
: "";
var isVirtual = //property.Modifiers.Any(SyntaxKind.VirtualKeyword) ||
property.Modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface
? " abstract "
: "";
//Adder
if (add != null && add.Body == null)
{
writer.Write(IsStatic);
//if (property.Modifiers.Any(SyntaxKind.AbstractKeyword)||isInterface)
{
writer.WriteLine(" " + isVirtual + " void Add_" + name + "(" + typeString + " value)" +
isOverride + "" + ";");
}
// else
// writer.WriteLine(" "+isVirtual + " void Add_" + name + "(" + typeString + " value)" +
// isOverride + " {" + fieldName + " = value;}");
}
else if (add != null)
{
writer.Write(IsStatic);
writeRegion(add, true);
}
//Remover
if (remove != null && remove.Body == null)
{
writer.Write(IsStatic);
//if (property.Modifiers.Any(SyntaxKind.AbstractKeyword)||isInterface)
{
writer.WriteLine(" " + isVirtual + " void Remove_" + name + "(" + typeString + " value)" +
isOverride + "" + ";");
}
}
else if (remove != null)
{
writer.Write(IsStatic);
writeRegion(remove, false);
}
if (isStatic)
{
var staticWriter = new OutputWriter("", "", false);
staticWriter.Write(name);
staticWriter.Write(" = new " + "__Event!(" + typeString + ")(new Action__G!(" + typeString +
")(&Add_" + name + "),new Action__G!(" + typeString +
")(&Remove_" + name + ") )");
staticWriter.Write(";");
staticWriter.WriteLine();
Context.Instance.StaticInits.Add(staticWriter.ToString());
}
}
}
public static void WriteIt(OutputWriter writer, MethodDeclarationSyntax method, bool isProxy = true)
{
writer.WriteLine();
var methodSymbol = (IMethodSymbol)TypeProcessor.GetDeclaredSymbol(method);
var methodName = OverloadResolver.MethodName(methodSymbol);
var pinvokeAttributes = method.GetAttribute(Context.DllImport);
// Fix this to actually look for the type, not just by name ...
//TODO: Improve partial class / method support -- partials classes work, methods need minor work ...
if (method.Modifiers.Any(SyntaxKind.PartialKeyword) && method.Body == null)
{
//We only want to render out one of the two partial methods. If there's another, skip this one.
if (Context.Instance.Partials.SelectMany(o => o.Syntax.As <ClassDeclarationSyntax>().Members)
.OfType <MethodDeclarationSyntax>()
.Except(method).Any(o => o.Identifier.ValueText == method.Identifier.ValueText))
{
return;
}
}
bool isoverride = ShouldUseOverrideKeyword(method, methodSymbol);
var accessString = "";
if (isoverride)
{
accessString += (" override ");
}
var isInterface = method.Parent is InterfaceDeclarationSyntax;
if (methodName == "Main" /*&& method.Modifiers.Any(SyntaxKind.PublicKeyword)*/ &&
method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
accessString = ("public ");
accessString += ("static ");
var methodCall = methodSymbol.ContainingNamespace.FullName() + "." +
methodSymbol.ContainingType.FullName() +
"." + methodName + (method.ParameterList.Parameters.Count < 1 ? "();" : "(null);");
//: "(new Array_T!(String)(args));"); // for now args not supported
Context.Instance.EntryMethod = methodCall;
}
else
{
if (method.Modifiers.Any(SyntaxKind.PublicKeyword) || method.Modifiers.Any(SyntaxKind.InternalKeyword) ||
method.Modifiers.Any(SyntaxKind.ProtectedKeyword) ||
method.Modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface)
{
accessString += ("public ");
}
if (method.Modifiers.Any(SyntaxKind.PrivateKeyword))
{
accessString += ("private ");
}
// if (method.Modifiers.Any(SyntaxKind.VirtualKeyword) || isInterface)
// writer.Write("virtual ");
// if (!(method.Modifiers.Any (SyntaxKind.VirtualKeyword) || (method.Modifiers.Any (SyntaxKind.AbstractKeyword) || isInterface || isoverride))) {
// writer.Write(" final ");
// }
if (method.Modifiers.Any(SyntaxKind.AbstractKeyword))
{
accessString += (" abstract ");
}
if (method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
accessString += ("static ");
}
}
// if (isInterface)
// {
// writer.IsInterface = true;
// }
var returnTypeString = TypeProcessor.ConvertType(method.ReturnType) + " ";
var methodSignatureString = "";
if (method.ReturnType.ToString() == "void")
{
returnTypeString = ("void ");
}
else
// bool returnsVoid = method.ReturnType.ToString() == "void";
//if (!returnsVoid)
{
var typeSymbol = TypeProcessor.GetTypeInfo(method.ReturnType).Type;
// var isPtr = typeSymbol != null && (typeSymbol.IsValueType || typeSymbol.TypeKind == TypeKind.TypeParameter) ? "" : "";
// var typeString = TypeProcessor.ConvertType(method.ReturnType) + isPtr + " ";
// writer.Write(typeString);
// writer.HeaderWriter.Write(typeString);
var isPtr = typeSymbol != null &&
(!typeSymbol.IsValueType || typeSymbol.TypeKind == TypeKind.TypeParameter);
}
if (methodSymbol.ContainingType.TypeKind == TypeKind.Interface ||
Equals(methodSymbol.ContainingType.FindImplementationForInterfaceMember(methodSymbol), methodSymbol))
{
methodName =
Regex.Replace(
TypeProcessor.ConvertType(methodSymbol.ContainingType.ConstructedFrom) + "_" + methodName,
@" ?!\(.*?\)", string.Empty);
}
if (methodName.Contains(".")) // Explicit Interface method
{
//
methodName = methodName.SubstringAfterLast('.');
methodName = methodName.Replace('.', '_');
}
// var typenameI = Regex.Replace (TypeProcessor.ConvertType (interfaceMethod.ContainingType), @" ?!\(.*?\)", string.Empty);
var interfaceMethods =
methodSymbol.ContainingType.AllInterfaces.SelectMany(
u =>
u.GetMembers(methodName)).ToArray();
ISymbol interfaceMethod =
interfaceMethods.FirstOrDefault(
o => methodSymbol.ContainingType.FindImplementationForInterfaceMember(o) == methodSymbol);
if (interfaceMethod == null)
{
//TODO: fix this for virtual method test 7, seems roslyn cannot deal with virtual
// overrides of interface methods ... so i'll provide a kludge
if (!method.Modifiers.Any(SyntaxKind.NewKeyword))
{
interfaceMethod =
interfaceMethods.FirstOrDefault(k => CompareMethods(k as IMethodSymbol, methodSymbol));
}
}
if (interfaceMethod != null)
// && CompareMethods(interfaceMethod ,methodSymbol)) {
{
//This is an interface method //TO
if (methodSymbol.ContainingType.SpecialType == SpecialType.System_Array)
{
methodSignatureString += ("");
}
else
{
var typenameI =
Regex.Replace(TypeProcessor.ConvertType(interfaceMethod.ContainingType.ConstructedFrom),
@" ?!\(.*?\)", string.Empty);
//TODO: we should be able to get the original interface name, or just remove all generics from this
if (typenameI.Contains('.'))
{
typenameI = typenameI.SubstringAfterLast('.');
}
methodName = (typenameI + "_") + methodName;
}
}
// var explicitHeaderNAme = "";
//FIX ME: To support explicits, all method calls are going to be prequalified with the interface name, lets just hope we dont have similar interfaces
//
// if (methodSymbol.MethodKind == MethodKind.ExplicitInterfaceImplementation)
// {
// // var implementations = methodSymbol.ExplicitInterfaceImplementations[0];
// if (implementations != null)
// {
// // explicitHeaderNAme = implementations.Name;
// methodName = TypeProcessor.ConvertType(implementations.ReceiverType) + "_" +implementations.Name; //Explicit fix ?
//
// // writer.Write(methodSymbol.ContainingType + "." + methodName);
// //Looks like internal classes are not handled properly here ...
// }
// }
// methodName = methodName.Replace(methodSymbol.ContainingNamespace.FullName() + ".", methodSymbol.ContainingNamespace.FullName().Replace(".", "::") + "::");
// (methodSymbol as).Is
// (methodSymbol as Microsoft.CodeAnalysis.CSharp.Symbols.SourceMethodSymbol);
if (method.Modifiers.Any(SyntaxKind.NewKeyword))
{
methodName += "_";
}
// writer.Write( TypeProcessor.ConvertType(methodSymbol.ContainingType)+ "." + methodName); //Dealting with explicit VMT7
// writer.Write(!String.IsNullOrEmpty(explicitHeaderNAme)? explicitHeaderNAme : methodName);
// writer.Write(methodName);
methodSignatureString += methodName;
if (method.TypeParameterList != null)
{
var genericArgs = method.TypeParameterList.Parameters.ToList();
// if (genericArgs.Count > 0)
// {
// writer.Write("( ");
// writer.Write(string.Join(" , ", genericArgs.Select(o => " " + o)));
// writer.Write(" )\r\n");
// }
if (genericArgs.Count > 0) // && !methodSymbol.ContainingType.IsGenericType) // doesnt matter
{
methodSignatureString += ("(");
methodSignatureString += (string.Join(",", genericArgs.Select(o => " " + o)));
methodSignatureString += (")");
}
}
var @params = GetParameterListAsString(method.ParameterList);
var constraints = "";
if (method.ConstraintClauses.Count > 0)
{
constraints += (" if (");
bool isFirst = true;
foreach (var constraint in method.ConstraintClauses)
{
foreach (var condition in constraint.Constraints)
{
string dlangCondition = condition.ToString();
if (dlangCondition == "new()")
{
continue;
}
if (dlangCondition == "class") // TODO: is there a better way to do this ?
{
dlangCondition = "NObject";
}
if (dlangCondition == "struct")
{
constraints += ((isFirst ? "" : "&&") + " !is(" + constraint.Name + " : NObject)");
}
else
{
constraints += ((isFirst ? "" : "&&") + " is(" + constraint.Name + " : " + dlangCondition +
")");
}
isFirst = false;
// Console.WriteLine (condition);
}
}
constraints += (")");
}
if (isInterface || method.Modifiers.Any(SyntaxKind.AbstractKeyword))
{
writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params + constraints + ";");
return;
}
writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params + constraints);
writer.OpenBrace();
if (isProxy)
{
@params = GetParameterListAsString(method.ParameterList, false);
if (method.ReturnType.ToString() == "void")
{
writer.WriteLine("Value." + methodName + @params + ";");
}
else
{
writer.WriteLine("return Value." + methodName + @params + ";");
}
}
else
{
if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
if (pinvokeAttributes != null)
{
WritePInvokeMethodBody.Go(writer, methodName, methodSymbol, pinvokeAttributes);
}
}
writer.CloseBrace();
}
public static void Go(OutputWriter writer, EventDeclarationSyntax property)
{
writer.WriteLine("\r\n");
var rEf = ""; //" ref ";// ref should be used based on analysis, is the return type a single var or not
//TODO, doesnt ref make things slower ?, though it makes proprties behave as in c#
var isInterface = property.Parent is InterfaceDeclarationSyntax;
var add =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.AddKeyword);
var remove =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.RemoveKeyword);
var methodSymbol =
(TypeProcessor.GetDeclaredSymbol(add) ?? TypeProcessor.GetDeclaredSymbol(remove)) as IMethodSymbol;
Action <AccessorDeclarationSyntax, bool> writeRegion = (region, get) =>
{
writer.WriteIndent();
// if (property.Modifiers.Any(SyntaxKind.PrivateKeyword))
// writer.HeaderWriter.Write("private:\n");
//
// if (property.Modifiers.Any(SyntaxKind.PublicKeyword) || property.Modifiers.Any(SyntaxKind.InternalKeyword))
// writer.HeaderWriter.Write("public ");
var typeinfo = TypeProcessor.GetTypeInfo(property.Type);
var isPtr = "";
var typeString = TypeProcessor.ConvertType(property.Type) + isPtr + " ";
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
{
writer.Write(" abstract ");
}
if (property.Modifiers.Any(SyntaxKind.OverrideKeyword))
{
writer.Write(" override ");
}
//TODO: look at final and other optimizations
// if (!(property.Modifiers.Any (SyntaxKind.VirtualKeyword) || (property.Modifiers.Any (SyntaxKind.AbstractKeyword)) || isInterface || property.Modifiers.Any(SyntaxKind.OverrideKeyword)) ) {
// writer.Write(" final ");
// }
//no inline in D
// if (get)
// {
// writer.Write(" " + rEf+ typeString + " ");
// writer.Write(typeString + " ");
// }
// else
// {
// writer.Write("_=(value");
// writer.Write(TypeProcessor.ConvertTypeWithColon(property.Type));
// writer.Write(")");
writer.Write("void ");
// writer.Write(" " + "void ");
// }
//not needed for Dlang
var methodName = (get ? "" : "") +
WriteIdentifierName.TransformIdentifier(property.Identifier.ValueText);
var explicitHeaderNAme = "";
if (methodSymbol != null && methodSymbol.MethodKind == MethodKind.ExplicitInterfaceImplementation)
{
var implementations = methodSymbol.ExplicitInterfaceImplementations[0];
if (implementations != null)
{
explicitHeaderNAme = implementations.Name;
methodName = //implementations.ReceiverType.FullName() + "." +
implementations.Name; //Explicit fix ?
// writer.Write(methodSymbol.ContainingType + "." + methodName);
//Looks like internal classes are not handled properly here ...
}
}
if (methodSymbol != null)
{
// methodName = methodName.Replace(methodSymbol.ContainingNamespace.FullName() + ".", methodSymbol.ContainingNamespace.FullName() + ".");
// writer.Write((methodSymbol.ContainingType.FullName() + "." + methodName) + (get ? "()" : "( " + typeString + " value )")); //Dealing with explicit VMT7
}
if (property.Modifiers.Any(SyntaxKind.NewKeyword))
{
methodName += "_";
}
writer.Write(
//(!String.IsNullOrEmpty(explicitHeaderNAme) ? explicitHeaderNAme : methodName)
(get ? "Add_" : "Remove_") + methodName + "( " + typeString + " value )");
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
{
writer.Write(";\r\n");
}
else
{
// writer.Write(";\r\n");
writer.OpenBrace();
// writer.Write(" =\r\n");
Core.WriteBlock(writer, region.Body.As <BlockSyntax>());
writer.CloseBrace();
writer.Write("\r\n");
}
};
if (add == null && remove == null)
{
throw new Exception("Property must have either a get or a set");
}
// if (getter != null && setter != null && setter.Body == null && getter.Body == null)
{
//Both get and set are null, which means this is an automatic property. For our purposes, this is the equivilant of a field//Nope
// WriteField.Go(writer,property, property.Modifiers, WriteIdentifierName.TransformIdentifier(property.Identifier.ValueText), property.Type);
var name = WriteIdentifierName.TransformIdentifier(property.Identifier.ValueText);
var type = property.Type;
var typeinfo = TypeProcessor.GetTypeInfo(type);
var modifiers = property.Modifiers;
var isPtr = typeinfo.Type != null &&
(typeinfo.Type.IsValueType || typeinfo.Type.TypeKind == TypeKind.TypeParameter)
? ""
: "";
var typeString = TypeProcessor.ConvertType(type) + isPtr + " ";
var isStatic = false;
//Handle Auto Properties
var accessors = property.AccessorList.Accessors; //.Where(o=>o.Body==null);
var accessString = "";
if (modifiers.Any(SyntaxKind.PrivateKeyword))
{
accessString += (" private ");
}
if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
accessString += (" public ");
}
// if (!(property.Modifiers.Any (SyntaxKind.VirtualKeyword) || (property.Modifiers.Any (SyntaxKind.AbstractKeyword)))) {
// writer.Write(" final ");
// }
// if (modifiers.Any(SyntaxKind.PublicKeyword) || method.Modifiers.Any(SyntaxKind.InternalKeyword) || modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword))
// writer.HeaderWriter.WriteLine("public: ");
var IsStatic = "";
if (modifiers.Any(SyntaxKind.StaticKeyword))
{
isStatic = true;
IsStatic = accessString += " static ";
// writer.HeaderWriter.Write("static ");
}
var fieldName = "__evt__" + name;
if (!isStatic)
{
writer.Write("private " + "Event!(" + typeString + ") " + fieldName + ";\r\n");
// Internal Field used for event
writer.Write(accessString);
writer.WriteLine("Event!(" + typeString + ") " + name + "() @property");
writer.OpenBrace();
writer.WriteLine("if (" + fieldName + " is null)");
writer.OpenBrace();
writer.Write(fieldName + " = new " + "Event!(" + typeString + ")(new Action_T!(" + typeString +
")(&Add_" + name + "),new Action_T!(" + typeString + ")(&Remove_" + name + ") );");
writer.CloseBrace();
writer.Write("return " + fieldName + ";");
writer.CloseBrace();
}
else
{
writer.Write(IsStatic);
writer.Write("Event!(" + typeString + ") " + name + ";\r\n");
}
//
var isOverride = property.Modifiers.Any(SyntaxKind.NewKeyword) ||
property.Modifiers.Any(SyntaxKind.OverrideKeyword)
? " override "
: "";
var isVirtual = //property.Modifiers.Any(SyntaxKind.VirtualKeyword) ||
property.Modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface
? " abstract "
: "";
// if(!isInterface)
// if ((add!=null && add.Body == null) ||
// (remove != null && remove.Body == null) && (!property.Modifiers.Any(SyntaxKind.AbstractKeyword)))
// {
//
// writer.Write (IsStatic);
// var initString = "";//isStatic?"":(" = " + TypeProcessor.DefaultValue (type));
// writer.Write (typeString + fieldName + initString + ";\r\n");
//
// }
//Adder
if (add != null && add.Body == null)
{
writer.Write(IsStatic);
//if (property.Modifiers.Any(SyntaxKind.AbstractKeyword)||isInterface)
{
writer.WriteLine(" " + isVirtual + " void Add_" + name + "(" + typeString + " value)" +
isOverride + "" + ";");
}
// else
// writer.WriteLine(" "+isVirtual + " void Add_" + name + "(" + typeString + " value)" +
// isOverride + " {" + fieldName + " = value;}");
}
else if (add != null)
{
writer.Write(IsStatic);
writeRegion(add, true);
}
//Remover
if (remove != null && remove.Body == null)
{
writer.Write(IsStatic);
//if (property.Modifiers.Any(SyntaxKind.AbstractKeyword)||isInterface)
{
writer.WriteLine(" " + isVirtual + " void Remove_" + name + "(" + typeString + " value)" +
isOverride + "" + ";");
}
//else
// writer.WriteLine(" "+isVirtual + " void Remove_" + name + "(" + typeString + " value)" +
// isOverride + " {" + fieldName + " = value;}");
}
else if (remove != null)
{
writer.Write(IsStatic);
writeRegion(remove, false);
}
if (isStatic)
{
var staticWriter = new OutputWriter("", "", false);
staticWriter.Write(name);
staticWriter.Write(" = new " + "Event!(" + typeString + ")(new Action_T!(" + typeString +
")(__ToDelegate(&Add_" + name + ")),new Action_T!(" + typeString +
")(__ToDelegate(&Remove_" + name + ")) )");
staticWriter.Write(";");
staticWriter.WriteLine();
Context.Instance.StaticInits.Add(staticWriter.ToString());
}
else
{
var staticWriter = new OutputWriter("", "", false);
staticWriter.Write(name);
staticWriter.Write(" = new " + "Event!(" + typeString + ")(new Action_T!(" + typeString +
")((&Add_" + name + ")),new Action_T!(" + typeString + ")((&Remove_" + name +
")) )");
staticWriter.Write(";");
staticWriter.WriteLine();
Context.Instance.InstanceInits.Add(staticWriter.ToString());
}
// if (CSharpExtensions.CSharpKind (initializerOpt.Value) == SyntaxKind.CollectionInitializerExpression || CSharpExtensions.CSharpKind (initializerOpt.Value) == SyntaxKind.ArrayInitializerExpression)
// {
//
//
// staticWriter.Write ("new " + typeStringNoPtr + " ([");
//
//
// }
// Core.Write (staticWriter, initializerOpt.Value);
// if (CSharpExtensions.CSharpKind (initializerOpt.Value) == SyntaxKind.CollectionInitializerExpression || CSharpExtensions.CSharpKind (initializerOpt.Value) == SyntaxKind.ArrayInitializerExpression)
// {
//
//
// staticWriter.Write ("])");
// }
}
}
public static void Go(OutputWriter writer, OperatorDeclarationSyntax method)
{
var methodSymbol = (IMethodSymbol)TypeProcessor.GetDeclaredSymbol(method);
var actualMethodName = OverloadResolver.MethodName(methodSymbol);
writer.Write("\n");
var returnType = "";
if (method.ReturnType.ToString() == "void")
{
returnType = ("void ");
}
else
{
returnType = TypeProcessor.ConvertType(method.ReturnType) + " ";
// writer.Write(returnType);
}
var methodName = "";
if (BinaryOperators.ContainsKey(actualMethodName))
{
methodName = "opBinary";
var typeSymbolParam0 = TypeProcessor.GetTypeInfo(method.ParameterList.Parameters[0].Type);
var typeSymbolParent = (methodSymbol.ContainingType);
if (typeSymbolParam0.Type != typeSymbolParent)
{
methodName += "Right";
}
}
if (UnaryOperators.ContainsKey(actualMethodName))
{
methodName = "opUnary";
}
if (EqualsOperators.ContainsKey(actualMethodName))
{
methodName = "opEquals";
}
if (CmpOperators.ContainsKey(actualMethodName))
{
methodName = "opCmp";
}
if (AssignOperators.ContainsKey(actualMethodName))
{
methodName = "opAssign";
}
if (AssignOpOperators.ContainsKey(actualMethodName))
{
methodName = "opOpAssign"; // need to remove = from the name
}
var paramType = method.ParameterList.Parameters[0];
if (method.ParameterList.Parameters.Count == 2)
{
if (methodName.EndsWith("Right"))
{
paramType = method.ParameterList.Parameters[0];
}
else
{
paramType = method.ParameterList.Parameters[1];
}
}
var token = method.OperatorToken.Text;
var methodBody = "";
var temp = new TempWriter();
foreach (var statement in method.Body.Statements)
{
Core.Write(temp, statement);
}
TriviaProcessor.ProcessTrivias(temp, method.Body.DescendantTrivia());
methodBody = temp.ToString();
if (methodName == "opOpAssign")
{
token = token.Substring(0, 1);
}
//We are going to have to rewrite this bit later ... for now all overloads are called directly
/* if (methodName == "opBinary")
* {
*
* writer.WriteLine("public final " + returnType + " " + methodName +
* String.Format(
* " (string _op) ({0} other)\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this,other); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
*
* //Add Assignment operator if it doesn't exist
* if (!methodSymbol.ContainingType.GetMembers(AssignOpOperators.FirstOrDefault(k => k.Value == token + "=").Key).Any())
* {
* writer.WriteLine("public final " + returnType + " opOpAssign" +
* String.Format(
* " (string _op) ({0} other)\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this,other); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
* }
* }
* else if (methodName == "opUnary")//TODO unary operators are mostly going to be direct methodCalls
* {
*
* writer.WriteLine("public final " + returnType + " " + methodName +
* String.Format(
* " (string _op) ()\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
* // writer.WriteLine ("public final ref " + returnType + " " + methodName +
* // String.Format (
* // " (string _op) ()\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\t{3}\r\n\t}}\r\n\r\n",
* //TypeProcessor.ConvertType (paramType.Type), actualMethodName, token, methodBody.Replace(method.ParameterList.Parameters[0].Identifier.ValueText,"this")));
* }
* else
* {
* writer.WriteLine("public final " + returnType + " " + methodName +
* String.Format(
* " (string _op) ({0} other)\r\n\tif(_op==\"{2}\")\r\n\t{{ \r\n\t\treturn {1}(this); \r\n\t}}\r\n\r\n",
* TypeProcessor.ConvertType(paramType.Type), actualMethodName, token));
* }*/
var @params = method.ParameterList.Parameters;
writer.WriteLine("public static " + returnType + " " + actualMethodName + WriteMethod.GetParameterListAsString(method.ParameterList.Parameters));
writer.OpenBrace();
if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
writer.CloseBrace();
}
public static void Go(OutputWriter writer, BasePropertyDeclarationSyntax property, bool isProxy = false)
{
writer.WriteLine();
//TODO, doesnt ref make things slower ?, though it makes proprties behave as in c#
var isInterface = property.Parent is InterfaceDeclarationSyntax;
var getter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.GetKeyword);
var setter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.SetKeyword);
var isYield = getter != null && getter.DescendantNodes().OfType <YieldStatementSyntax>().Any();
var isStatic = property.Modifiers.Any(k => k.IsKind(SyntaxKind.StaticKeyword));
ITypeSymbol iface;
ISymbol[] proxies;
var name = MemberUtilities.GetMethodName(property, ref isInterface, out iface, out proxies);
var modifiers = property.Modifiers;
var propertySymbol = (IPropertySymbol)TypeProcessor.GetDeclaredSymbol(property);
var type = propertySymbol.Type;
var acccessmodifiers = MemberUtilities.GetAccessModifiers(property, isInterface || propertySymbol.IsAbstract);
var typeString = TypeProcessor.ConvertType(type);
var hasGetter = getter != null;
var getterHasBody = hasGetter && getter.Body != null;
var hasSetter = setter != null;
var setterHasBody = hasSetter && setter.Body != null;
var indexerDeclarationSyntax = property as IndexerDeclarationSyntax;
var isindexer = indexerDeclarationSyntax != null;
string getterbody = null;
if (getterHasBody)
{
getterbody = Core.WriteBlock(getter.Body, false, writer.Indent + 2);
if (!isProxy && isYield)
{
var namedTypeSymbol = propertySymbol.Type as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
// var iteratortype = namedTypeSymbol.TypeArguments[0];
// getterbody=String.Format("return new __IteratorBlock!({0})(delegate(__IteratorBlock!({0}) __iter){{ {1} }});",
// TypeProcessor.ConvertType(iteratortype),getterbody);
var className = propertySymbol.GetYieldClassName() + (
(((INamedTypeSymbol)propertySymbol.Type).TypeArguments.Any() && ((INamedTypeSymbol)propertySymbol.Type).TypeArguments[0].TypeKind == TypeKind.TypeParameter) ? "__G" : "");
// writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params2 + constraints);
//writer.OpenBrace();
if (!propertySymbol.IsStatic)
{
getterbody = writer.WriteIndentToString() + ("return new " + className + "(this);");
}
else
{
getterbody = writer.WriteIndentToString() + ("return new " + className + "();");
}
}
}
}
string setterbody = null;
if (setterHasBody)
{
setterbody = Core.WriteString(setter.Body, false, writer.Indent + 2);
if (isindexer)
{
setterbody += writer.WriteIndentToString() + "return value;";
}
else
{
if (hasGetter)
{
setterbody += writer.WriteIndentToString() + "return " + name + ";";
}
}
}
if (getter == null && setter == null)
{
throw new Exception("Property must have either a get or a set");
}
string isOverride;
var fieldName = WriteAutoFieldName(writer, name, modifiers, isInterface, hasGetter, getterHasBody,
hasSetter, setterHasBody, typeString, out isOverride, (property is IndexerDeclarationSyntax));
BracketedParameterListSyntax @params = null;
if (indexerDeclarationSyntax != null)
{
@params = indexerDeclarationSyntax.ParameterList;
}
string parameters = null;
if (@params != null)
{
parameters = WriteMethod.GetParameterListAsString(@params.Parameters, iface: proxies == null ? iface : null, writebraces: false);
}
WriteGetter(writer, isProxy, hasGetter, acccessmodifiers, typeString, name, proxies == null ? iface : null, getterHasBody, modifiers, isInterface, fieldName, getterbody, parameters, indexerDeclarationSyntax != null);
WriteSetter(writer, isProxy, hasSetter, acccessmodifiers, name, typeString, proxies == null ? iface : null, isOverride, setterHasBody, modifiers, isInterface, fieldName, setterbody, parameters, isindexer, hasGetter);
// if (!isindexer && !isInterface) //TODO: Find a better solution
// {
// var fieldacccessmodifiers = acccessmodifiers.Replace ("abstract", "").Replace ("virtual","").Replace("override","");
//
// writer.WriteLine(fieldacccessmodifiers + "__Property!(" + typeString + ")" + name + ";");
// if (isStatic)
// {
// var staticWriter = new TempWriter ();
//
// staticWriter.WriteLine (name + String.Format (" = __Property!(" + typeString + ")(__ToDelegate(&set{0}), __ToDelegate(&get{0}));", name));
// Context.Instance.StaticInits.Add (staticWriter.ToString ());
// }
// else
// {
// var instanceWriter = new TempWriter ();
//
// instanceWriter.WriteLine (name + String.Format (" = __Property!(" + typeString + ")((&set{0}), (&get{0}));", name));
// Context.Instance.InstanceInits.Add (instanceWriter.ToString ());
// }
// }
if (proxies != null)
{
foreach (var proxy in proxies)
{
if (indexerDeclarationSyntax == null)
{
setterbody = writer.WriteIndentToString() + name + "=" + "value" + ";";
getterbody = writer.WriteIndentToString() + "return " + name + ";";
}
else
{
string parameters2 = "";
if (@params != null)
{
parameters2 = WriteMethod.GetParameterListAsString(@params.Parameters, iface: null, includeTypes: false, writebraces: false);
// parameters2 = WriteMethod.GetParameterListAsString(@params.Parameters, iface: proxies == null ? iface : null, writebraces: false);
}
setterbody = writer.WriteIndentToString() + "return opIndexAssign(value," + parameters2 + ");";// + "=" + "value" + ";";
getterbody = writer.WriteIndentToString() + "return opIndex(" + parameters2 + ");";
}
parameters = null;
if (@params != null)
{
parameters = WriteMethod.GetParameterListAsString(@params.Parameters, iface: proxy.ContainingType, writebraces: false);
}
WriteGetter(writer, isProxy, hasGetter, acccessmodifiers, typeString, name, proxy.ContainingType, getterHasBody, modifiers, isInterface, fieldName, getterbody, parameters, isindexer);
WriteSetter(writer, isProxy, hasSetter, acccessmodifiers, name, typeString, proxy.ContainingType, isOverride, setterHasBody, modifiers, isInterface, fieldName, setterbody, parameters, isindexer, hasGetter);
}
}
}
public static void Go(OutputWriter writer, OperatorDeclarationSyntax method)
{
var methodSymbol = (IMethodSymbol)TypeProcessor.GetDeclaredSymbol(method);
var ActualMethodName = OverloadResolver.MethodName(methodSymbol);
// var methodType = Program.GetModel(method).GetTypeInfo(method);
writer.Write("\n");
var isInterface = method.Parent is InterfaceDeclarationSyntax;
if (method.Modifiers.Any(SyntaxKind.PublicKeyword) || method.Modifiers.Any(SyntaxKind.InternalKeyword) ||
method.Modifiers.Any(SyntaxKind.ProtectedKeyword) || method.Modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
writer.Write("public ");
}
var returnType = "";
if (method.ReturnType.ToString() == "void")
{
writer.Write("void ");
}
else
{
// var typeSymbol = TypeProcessor.GetTypeInfo(method.ReturnType).Type;
// var isPtr = typeSymbol != null && (typeSymbol.IsValueType || typeSymbol.TypeKind == TypeKind.TypeParameter) ? "" : "";
// var typeString = TypeProcessor.ConvertType(method.ReturnType) + isPtr + " ";
// writer.Write(typeString);
// writer.HeaderWriter.Write(typeString);
// var isPtr = typeSymbol != null && (!typeSymbol.IsValueType || typeSymbol.TypeKind == TypeKind.TypeParameter);
returnType = TypeProcessor.ConvertType(method.ReturnType) + " ";
writer.Write(returnType);
}
var methodName = "";
if (binaryOperators.Contains(method.OperatorToken.ValueText))
{
methodName = "opBinary";
var typeSymbolParam0 = TypeProcessor.GetTypeInfo(method.ParameterList.Parameters[0].Type);
var typeSymbolParent = (methodSymbol.ContainingType);
if (typeSymbolParam0.Type != typeSymbolParent)
{
methodName += "Right";
}
}
if (unaryOperators.Contains(method.OperatorToken.ValueText))
{
methodName = "opUnary";
}
if (equalsOperators.Contains(method.OperatorToken.ValueText))
{
methodName = "opEquals";
}
if (cmpOperators.Contains(method.OperatorToken.ValueText))
{
methodName = "opCmp";
}
if (assignOperators.Contains(method.OperatorToken.ValueText))
{
methodName = "opAssign";
}
if (assignOpOperators.Contains(method.OperatorToken.ValueText))
{
methodName = "opOpAssign"; // need to remove = from the name
}
//method.ParameterList.Parameters[0];
var paramType = method.ParameterList.Parameters[0];
if (method.ParameterList.Parameters.Count == 2)
{
if (methodName.EndsWith("Right"))
{
paramType = method.ParameterList.Parameters[0];
}
else
{
paramType = method.ParameterList.Parameters[1];
}
}
var token = method.OperatorToken.ValueText;
if (methodName == "opOpAssign")
{
token = token.Substring(0, 1);
}
writer.Write(methodName +
String.Format(
" (string _op) ({0} other)\r\nif(_op==\"{2}\")\r\n{{ \r\nreturn {1}(this,other); \r\n}}\r\n",
TypeProcessor.ConvertType(paramType.Type), ActualMethodName, token));
writer.Write("\r\n\r\npublic static " + returnType + " " + ActualMethodName);
WriteParameterList(writer, method.ParameterList);
writer.WriteLine();
writer.OpenBrace();
writer.WriteLine();
if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
writer.WriteLine();
writer.CloseBrace();
writer.WriteLine();
}
public static void Go(OutputWriter writer, PropertyDeclarationSyntax property, bool isProxy = false)
{
writer.WriteLine();
//var rEf = "";//" ref ";// ref should be used based on analysis, is the return type a single var or not
//TODO, doesnt ref make things slower ?, though it makes proprties behave as in c#
var isInterface = property.Parent is InterfaceDeclarationSyntax;
var getter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.GetKeyword);
var setter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.SetKeyword);
var methodSymbol = TypeProcessor.GetDeclaredSymbol(property);
var name = WriteIdentifierName.TransformIdentifier(property.Identifier.ValueText);
if (methodSymbol.ContainingType.TypeKind == TypeKind.Interface)
{
isInterface = true;
}
if (methodSymbol.ContainingType.TypeKind == TypeKind.Interface ||
Equals(methodSymbol.ContainingType.FindImplementationForInterfaceMember(methodSymbol), methodSymbol))
{
name = Regex.Replace(
TypeProcessor.ConvertType(methodSymbol.ContainingType.ConstructedFrom) + "_" + name,
@" ?!\(.*?\)", string.Empty);
}
if (name.Contains(".")) // Explicit Interface method
{
//
name = name.SubstringAfterLast('.');
name = name.Replace('.', '_');
}
var interfaceMethods =
methodSymbol.ContainingType.AllInterfaces.SelectMany(
u =>
u.GetMembers(name)).ToArray();
ISymbol interfaceMethod =
interfaceMethods.FirstOrDefault(
o => methodSymbol.ContainingType.FindImplementationForInterfaceMember(o) == methodSymbol);
if (interfaceMethod != null)
{
//This is an interface property //TO
if (methodSymbol.ContainingType.SpecialType == SpecialType.System_Array)
{
writer.Write("");
}
else
{
var typenameI =
Regex.Replace(TypeProcessor.ConvertType(interfaceMethod.ContainingType.ConstructedFrom),
@" ?!\(.*?\)", string.Empty);
//TODO: we should be able to get the original interface name, or just remove all generics from this
if (typenameI.Contains('.'))
{
typenameI = typenameI.SubstringAfterLast('.');
}
name = (typenameI + "_") + name;
}
}
Action <AccessorDeclarationSyntax, bool> writeRegion = (region, get) =>
{
var accessString = "";
// var typeinfo = TypeProcessor.GetTypeInfo(property.Type);
var isPtr = "";
var typeString = TypeProcessor.ConvertType(property.Type) + isPtr + " ";
//no inline in D
if (get)
{
writer.Write(typeString + " ");
}
else
{
writer.Write("void ");
}
var methodName = (get ? "" : "") +
name;
var explicitHeaderNAme = "";
if (property.Modifiers.Any(SyntaxKind.NewKeyword))
{
methodName += "_";
}
writer.Write((!String.IsNullOrEmpty(explicitHeaderNAme) ? explicitHeaderNAme : methodName) +
(get ? "()" : "( " + typeString + " value )") + " @property");
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
{
writer.Write(";\r\n");
}
else
{
writer.WriteLine();
writer.OpenBrace();
Core.WriteBlock(writer, region.Body.As <BlockSyntax>(), false);
writer.CloseBrace();
writer.WriteLine();
}
};
if (getter == null && setter == null)
{
throw new Exception("Property must have either a get or a set");
}
{
var type = property.Type;
var typeinfo = TypeProcessor.GetTypeInfo(type);
var modifiers = property.Modifiers;
var isPtr = "";
var typeString = TypeProcessor.ConvertType(type) + isPtr + " ";
var isStatic = false;
var acccessmodifiers = "";
if (modifiers.Any(SyntaxKind.PrivateKeyword))
{
acccessmodifiers += ("private ");
}
if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
acccessmodifiers += ("public ");
}
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword))
{
acccessmodifiers += "abstract ";
}
if (property.Modifiers.Any(SyntaxKind.OverrideKeyword) && !isInterface)
{
acccessmodifiers += "override ";
}
//TODO: look at final and other optimizations
var IsStatic = "";
if (modifiers.Any(SyntaxKind.StaticKeyword))
{
isStatic = true;
IsStatic = "static ";
acccessmodifiers += IsStatic;
}
//Auto Property
var fieldName = "__prop_" + name;
var isOverride = (property.Modifiers.Any(SyntaxKind.NewKeyword) ||
property.Modifiers.Any(SyntaxKind.OverrideKeyword)) && !isInterface
? " override "
: "";
// var isVirtual = //property.Modifiers.Any(SyntaxKind.VirtualKeyword) ||
// property.Modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface
// ? " abstract "
// : "";
if (!isInterface) // Auto property
{
if ((getter != null && getter.Body == null) &&
(setter != null && setter.Body == null) && (!property.Modifiers.Any(SyntaxKind.AbstractKeyword)))
{
writer.WriteLine("private " + typeString + fieldName + ";");
}
}
if (getter != null && isProxy)
{
writer.WriteLine(acccessmodifiers + isOverride + typeString + "" + name + "() " + "@property " +
"{ return Value." + name + ";}");
}
else
//Getter
if (getter != null && getter.Body == null)
{
if (isProxy)
{
}
else if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface)
{
writer.WriteLine(acccessmodifiers + typeString + " " + name + "()" + isOverride +
" @property;");
}
else
{
writer.WriteLine(acccessmodifiers + isOverride + typeString + "" + name + "() " +
"@property " + "{ return " + fieldName + ";}");
}
}
else if (getter != null)
{
writer.WriteIndent();
writer.Write(acccessmodifiers);
writeRegion(getter, true);
}
if (setter != null && isProxy)
{
writer.WriteLine(acccessmodifiers + " void " + name + "(" + typeString + " value) @property" +
isOverride + " { Value." + name + " = value;}");
}
else
//Setter
if (setter != null && setter.Body == null)
{
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || isInterface)
{
writer.WriteLine(acccessmodifiers + " void " + name + "(" + typeString + " value)" +
isOverride + "" + " @property;");
}
else
{
writer.WriteLine(acccessmodifiers + " void " + name + "(" + typeString + " value) @property" +
isOverride + " {" + fieldName + " = value;}");
}
}
else if (setter != null)
{
writer.WriteIndent();
writer.Write(acccessmodifiers);
writeRegion(setter, false);
}
}
}
public static void WriteInstanceConstructor(OutputWriter writer, ConstructorDeclarationSyntax method)
{
var methodSymbol = (IMethodSymbol)TypeProcessor.GetDeclaredSymbol(method);
var methodName = OverloadResolver.MethodName(methodSymbol);
// var methodType = Program.GetModel(method).GetTypeInfo(method);
//TODO: Improve partial class / method support
if (method.Modifiers.Any(SyntaxKind.PartialKeyword) && method.Body == null)
{
//We only want to render out one of the two partial methods. If there's another, skip this one.
if (Context.Instance.Partials.SelectMany(o => o.Syntax.As <ClassDeclarationSyntax>().Members)
.OfType <ConstructorDeclarationSyntax>()
.Except(method).Any(o => o.Identifier.ValueText == method.Identifier.ValueText))
{
return;
}
}
// if (method.Identifier.ValueText == "GetEnumerator")
// return; //TODO: Support enumerator methods
writer.WriteLine();
// writer.WriteIndent();
var accessmodifiers = "";
var isInterface = method.Parent is InterfaceDeclarationSyntax;
if (method.Modifiers.Any(SyntaxKind.PublicKeyword) || method.Modifiers.Any(SyntaxKind.InternalKeyword) ||
method.Modifiers.Any(SyntaxKind.ProtectedKeyword) || method.Modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
accessmodifiers += ("public ");
}
if (method.Modifiers.Any(SyntaxKind.PrivateKeyword))
{
accessmodifiers += ("private ");
}
if (ShouldUseOverrideKeyword(method, methodSymbol))
{
accessmodifiers += ("override ");
}
//D does not use the virtual keyword
// if (method.Modifiers.Any(SyntaxKind.VirtualKeyword) || isInterface)
// writer.Write("virtual ");
//Need to improve performance by labling non virtual methods with "final" ... but we have to check the original definition of the method
if (method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
accessmodifiers += ("static ");
}
if (isInterface)
{
// writer.IsInterface = true;
}
//Constructors in d dont have return types
// writer.Write("void ");
// writer.HeaderWriter.Write("void ");
// writer.Write("this");
// writer.Write("(");
// var firstParam = true;
// foreach (var parameter in method.ParameterList.Parameters)
// {
// bool isRef = parameter.Modifiers.Any(SyntaxKind.OutKeyword) ||
// parameter.Modifiers.Any(SyntaxKind.RefKeyword);
//
// if (firstParam)
// firstParam = false;
// else
// {
// writer.Write(", ");
// }
//
//
// var localSymbol = TypeProcessor.GetTypeInfo(parameter.Type);
// var ptr = (localSymbol.Type != null && !localSymbol.Type.IsValueType) ? "" : "";
//
// if (!isRef)
// {
// var s = TypeProcessor.ConvertType(parameter.Type) + " " + ptr;
// writer.Write(s);
// }
// else
// {
//
//
//
// var s = " ref " + TypeProcessor.ConvertType(parameter.Type) + " "; // Refs in D are simple
//
// writer.Write(s);
//
// Program.RefOutSymbols.TryAdd(TypeProcessor.GetDeclaredSymbol(parameter), null);
// }
//
// writer.Write(WriteIdentifierName.TransformIdentifier(parameter.Identifier.ValueText));
//
// if (parameter.Default != null)
// {
// writer.Write(" = ");
// Core.Write(writer, parameter.Default.Value);
// }
// }
//
// writer.Write(")");
writer.WriteLine(accessmodifiers + "this" + WriteMethod.GetParameterListAsString(method.ParameterList));
if (isInterface || method.Modifiers.Any(SyntaxKind.AbstractKeyword))
{
writer.Write(" = 0;\r\n");
return;
}
//if (!returnsVoid)
// writer.Write(" =");
// writer.Write("\r\n");
writer.OpenBrace();
if (method.Initializer != null)
{
//writer.Write(":");
Core.Write(writer, method.Initializer);
writer.Write(";");
writer.WriteLine(); //";\r\n");
}
if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
writer.CloseBrace();
}
private static void WriteOutNestedTypes(Context.SyntaxAndSymbol first, OutputWriter writer)
{
//WriteOut All My nested classes
Context.Push();
var delegates = first.Syntax.DescendantNodes().OfType <DelegateDeclarationSyntax>()
.Select(o => new
{
Syntax = o,
Symbol = TypeProcessor.GetDeclaredSymbol(o),
TypeName = WriteType.TypeName((INamedTypeSymbol)TypeProcessor.GetDeclaredSymbol(o))
}).Where(k => k.Symbol.ContainingType == Context.Instance.Type) // Ignore all nested delegates
.GroupBy(o => o.Symbol.ContainingNamespace.FullNameWithDot() + o.TypeName)
.ToList();
delegates.ForEach(type => //.ForEach(type => //.Parallel(type =>
{
Context.Instance = new Context
{
TypeName = type.First().TypeName,
DelegatePartials =
type.Select(
o =>
new Context.DelegateSyntaxAndSymbol
{
Symbol = (INamedTypeSymbol)o.Symbol,
Syntax = o.Syntax
})
.Where(o => !Program.DoNotWrite.ContainsKey(o.Syntax))
.ToList()
};
if (Context.Instance.DelegatePartials.Count > 0)
{
WriteDelegate.Go(writer);
}
});
Context.Pop();
Context.Push();
var subclasses = first.Syntax.DescendantNodes().OfType <BaseTypeDeclarationSyntax>()
.Select(o => new
{
Syntax = o,
Symbol = TypeProcessor.GetDeclaredSymbol(o),
TypeName = WriteType.TypeName((INamedTypeSymbol)TypeProcessor.GetDeclaredSymbol(o))
}).Where(k => k.Symbol.ContainingType == Context.Instance.Type) // Ignore all nested classes
.GroupBy(o => o.Symbol.ContainingNamespace.FullNameWithDot() + o.TypeName)
.ToList();
subclasses.ForEach(type => //.ForEach(type => //.Parallel(type =>
{
Context.Instance = new Context
{
TypeName = type.First().TypeName,
Partials =
type.Select(
o =>
new Context.SyntaxAndSymbol
{
Symbol = (INamedTypeSymbol)o.Symbol,
Syntax = o.Syntax
})
.Where(o => !Program.DoNotWrite.ContainsKey(o.Syntax))
.ToList()
};
if (Context.Instance.Partials.Count > 0)
{
try
{
WriteType.Go(writer);
}
catch (Exception ex)
{
//TODO: remove this when done with CorLib
throw ex;
}
}
});
Context.Pop();
}
public static void Go(OutputWriter writer, IndexerDeclarationSyntax property)
{
// writer.WriteLine ("\r\n");
var rEf = ""; //" ref ";// ref should be used based on analysis, is the return type a single var or not
//TODO, doesnt ref make things slower ?, though it makes proprties behave as in c#
var isInterface = property.Parent is InterfaceDeclarationSyntax;
var getter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.GetKeyword);
var setter =
property.AccessorList.Accessors.SingleOrDefault(
o => o.Keyword.RawKind == (decimal)SyntaxKind.SetKeyword);
var methodSymbol =
(TypeProcessor.GetDeclaredSymbol(getter) ?? TypeProcessor.GetDeclaredSymbol(setter)) as IMethodSymbol;
Action <AccessorDeclarationSyntax, bool> writeRegion = (region, get) =>
{
var typeinfo = TypeProcessor.GetTypeInfo(property.Type);
var isPtr = "";
var typeString = TypeProcessor.ConvertType(property.Type) + isPtr + " ";
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
{
writer.Write(" abstract ");
}
if (property.Modifiers.Any(SyntaxKind.OverrideKeyword))
{
writer.Write(" override ");
}
//TODO: look at final and other optimizations
//no inline in D
if (get)
{
writer.Write(rEf + typeString + " ");
}
else
{
writer.Write("void ");
}
var methodName = (get ? "opIndex" : "opIndexAssign");
var explicitHeaderNAme = "";
if (methodSymbol != null && methodSymbol.MethodKind == MethodKind.ExplicitInterfaceImplementation)
{
var implementations = methodSymbol.ExplicitInterfaceImplementations[0];
if (implementations != null)
{
explicitHeaderNAme = implementations.Name;
methodName = //implementations.ReceiverType.FullName() + "." +
implementations.Name; //Explicit fix ?
// writer.Write(methodSymbol.ContainingType + "." + methodName);
//Looks like internal classes are not handled properly here ...
}
}
if (methodSymbol != null)
{
// methodName = methodName.Replace(methodSymbol.ContainingNamespace.FullName() + ".", methodSymbol.ContainingNamespace.FullName() + ".");
// writer.Write((methodSymbol.ContainingType.FullName() + "." + methodName) + (get ? "()" : "( " + typeString + " value )")); //Dealting with explicit VMT7
}
if (property.Modifiers.Any(SyntaxKind.NewKeyword))
{
methodName += "_";
}
var parameters = GetParameterList(methodSymbol.Parameters);
writer.Write((!String.IsNullOrEmpty(explicitHeaderNAme) ? explicitHeaderNAme : methodName) + "( " +
(get ? "" : (typeString + " value, ")) + parameters + " )");
if (property.Modifiers.Any(SyntaxKind.AbstractKeyword) || region.Body == null)
{
writer.Write(";\r\n");
}
else
{
writer.OpenBrace();
Core.WriteBlock(writer, region.Body.As <BlockSyntax>());
writer.CloseBrace();
writer.Write("\r\n");
}
};
if (getter == null && setter == null)
{
throw new Exception("Property must have either a get or a set");
}
{
// var name = WriteIdentifierName.TransformIdentifier (property..ValueText);
var type = property.Type;
var typeinfo = TypeProcessor.GetTypeInfo(type);
var modifiers = property.Modifiers;
var isPtr = typeinfo.Type != null &&
(typeinfo.Type.IsValueType || typeinfo.Type.TypeKind == TypeKind.TypeParameter)
? ""
: "";
var typeString = TypeProcessor.ConvertType(type) + isPtr + " ";
var isStatic = false;
var acccessmodifiers = "";
if (modifiers.Any(SyntaxKind.PrivateKeyword))
{
acccessmodifiers += ("private ");
}
if (modifiers.Any(SyntaxKind.PublicKeyword) || modifiers.Any(SyntaxKind.InternalKeyword) ||
modifiers.Any(SyntaxKind.ProtectedKeyword) || modifiers.Any(SyntaxKind.AbstractKeyword) ||
isInterface)
{
acccessmodifiers += ("public ");
}
var IsStatic = "";
if (modifiers.Any(SyntaxKind.StaticKeyword))
{
isStatic = true;
IsStatic = "static ";
acccessmodifiers += IsStatic;
}
//Auto Property
// var isOverride = property.Modifiers.Any (SyntaxKind.NewKeyword) ||
// property.Modifiers.Any (SyntaxKind.OverrideKeyword)
// ? " override "
// : "";
// var isVirtual = //property.Modifiers.Any(SyntaxKind.VirtualKeyword) ||
// property.Modifiers.Any (SyntaxKind.AbstractKeyword) || isInterface
// ? " abstract "
// : "";
// if (!isInterface)
//Getter
if (getter != null)
{
writer.WriteIndent();
writer.Write(acccessmodifiers);
writeRegion(getter, true);
}
//Setter
if (setter != null)
{
writer.WriteIndent();
writer.Write(acccessmodifiers);
writeRegion(setter, false);
}
}
}
public static string GetMethodName(MemberDeclarationSyntax member, ref bool isInterface, out ITypeSymbol interfaceImplemented, out ISymbol[] proxies)
{
interfaceImplemented = null;
proxies = null;
var methodSymbol = TypeProcessor.GetDeclaredSymbol(member);
var name = WriteIdentifierName.TransformIdentifier(OverloadResolver.MethodName(methodSymbol));
if (methodSymbol.ContainingType.TypeKind == TypeKind.Interface)
{
isInterface = true;
interfaceImplemented = methodSymbol.ContainingType;
}
var isinterfacemethod = Equals(methodSymbol.ContainingType.FindImplementationForInterfaceMember(methodSymbol),
methodSymbol);
if (!isinterfacemethod && methodSymbol.IsOverride)
{
isinterfacemethod = Equals(methodSymbol.ContainingType.BaseType.FindImplementationForInterfaceMember(methodSymbol),
methodSymbol);
}
if (methodSymbol.ContainingType.TypeKind == TypeKind.Interface ||
(isinterfacemethod && methodSymbol.IsOverride))
{
/* name = Regex.Replace(
* TypeProcessor.ConvertType(methodSymbol.ContainingType.ConstructedFrom) + "_" + name,
* @" ?!\(.*?\)", String.Empty);*/
interfaceImplemented = methodSymbol.ContainingType.ConstructedFrom;
if (methodSymbol.ContainingType.ContainingType != null)
{
name = name.RemoveFromStartOfString(methodSymbol.ContainingType.ContainingType.Name + ".");
}
}
if (name.Contains(".")) // Explicit Interface method
{
//
name = name.SubstringAfterLast('.');
name = name.Replace('.', '_');
}
var name1 = name;
IEnumerable <ISymbol> interfaceMethods = null;
if (methodSymbol.IsOverride && (interfaceMethods == null || !interfaceMethods.Any()))
{
interfaceMethods =
methodSymbol.ContainingType.BaseType.AllInterfaces.SelectMany(
u =>
u.GetMembers(name1));
if ((interfaceMethods == null || !interfaceMethods.Any()))
{
interfaceMethods =
interfaceMethods.Where(
o => Equals(methodSymbol.ContainingType.BaseType.FindImplementationForInterfaceMember(o), methodSymbol));
}
}
else
{
interfaceMethods =
methodSymbol.ContainingType.AllInterfaces.SelectMany(
u =>
u.GetMembers(name1));
interfaceMethods =
interfaceMethods.Where(
o => Equals(methodSymbol.ContainingType.FindImplementationForInterfaceMember(o), methodSymbol));
}
var enumerable = interfaceMethods as ISymbol[] ?? interfaceMethods.ToArray();
var interfaceMethod = enumerable.FirstOrDefault();
if (interfaceMethods.Count() > 1)
{
proxies = interfaceMethods.ToArray();
}
if (interfaceMethod != null)
{
//TODO: fix this for virtual method test 7, seems roslyn cannot deal with virtual
// overrides of interface methods ... so i'll provide a kludge
// if (!member.GetModifiers().Any(SyntaxKind.NewKeyword) && methodSymbol is IMethodSymbol) // This is not neccessary for properties
// {
// interfaceMethod =
// enumerable.FirstOrDefault(k => CompareMethods(k as IMethodSymbol, (IMethodSymbol) methodSymbol));
// }
}
if (interfaceMethod != null)
{
//This is an interface method/property //TO
if (methodSymbol.ContainingType.SpecialType == SpecialType.System_Array)
{
name += ("");
}
else
{
/* var typenameI =
* Regex.Replace(TypeProcessor.ConvertType(interfaceMethod.ContainingType.ConstructedFrom),
* @" ?!\(.*?\)", String.Empty);*/
//TODO: we should be able to get the original interface name, or just remove all generics from this
interfaceImplemented = interfaceMethod.ContainingType;//.ConstructedFrom;
/* if (typenameI.Contains('.'))
* typenameI = typenameI.SubstringAfterLast('.');
* name = (typenameI + "_") + name;*/
}
}
// if (member.GetModifiers().Any(SyntaxKind.NewKeyword) && methodSymbol.OriginalDefinition.ContainingType.TypeKind != TypeKind.Interface) //Take care of new
// name += "_";
if (methodSymbol.IsNew())
{
// name += "_";
interfaceImplemented = methodSymbol.OriginalDefinition.ContainingType;
}
GetExplicitInterface(ref interfaceImplemented, methodSymbol);
// if (interfaceMethods.Count() >= 1 && interfaceMethod!=null)
// proxies = interfaceMethods.ToArray();
return(name);
}
public static void WriteIt(OutputWriter writer, MethodDeclarationSyntax method, bool isProxy = true, IEnumerable <ITypeSymbol> virtualGenericClasses = null)
{
var methodSymbol = (IMethodSymbol)TypeProcessor.GetDeclaredSymbol(method);
var isYield = YieldChecker.HasYield(method);//method.DescendantNodes().OfType<YieldStatementSyntax>().Any();
writer.WriteLine();
var pinvokeAttributes = method.GetAttribute(Context.DllImport);
var isInternalPInvoke = pinvokeAttributes == null && method.Modifiers.Any(SyntaxKind.ExternKeyword);
//TODO: Improve partial class / method support -- partials classes work, methods need minor work ...
if (method.Modifiers.Any(SyntaxKind.PartialKeyword) && method.Body == null)
{
//We only want to render out one of the two partial methods. If there's another, skip this one.
if (Context.Instance.Partials.SelectMany(o => o.Syntax.As <ClassDeclarationSyntax>().Members)
.OfType <MethodDeclarationSyntax>()
.Except(method).Any(o => o.Identifier.Text == method.Identifier.Text))
{
return;
}
}
var accessString = "";
var isInterface = method.Parent is InterfaceDeclarationSyntax;
ITypeSymbol iface;
ISymbol[] proxies;
var methodName = MemberUtilities.GetMethodName(method, ref isInterface, out iface, out proxies); //
var originalMethodName = methodName;
var containingType = iface == null ? methodSymbol.ContainingType : iface;
if (virtualGenericClasses != null)
{
methodName = TypeProcessor.ConvertType(containingType, false, false, false).Replace(".", "_") + "_" + methodName;
accessString = "public static final ";
}
else if (methodName == "Main" /*&& method.Modifiers.Any(SyntaxKind.PublicKeyword)*/ &&
method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
accessString = ("public ");
accessString += ("static ");
var methodCall = methodSymbol.ContainingNamespace.FullName() + "." +
methodSymbol.ContainingType.FullName() +
"." + methodName + (method.ParameterList.Parameters.Count < 1 ? "();" : "(null);");
//: "(new Array_T!(String)(args));"); // for now args not supported
Context.Instance.EntryMethod = methodCall;
}
else
{
accessString = MemberUtilities.GetAccessModifiers(method, isInterface || methodSymbol.IsAbstract);
}
var returnTypeString = TypeProcessor.ConvertType(method.ReturnType, true) + " ";
var methodSignatureString = "";
if (method.ReturnType.ToString() == "void")
{
returnTypeString = ("void ");
}
methodSignatureString += methodName;
var genericParameters = "";
if (method.TypeParameterList != null)
{
var genericArgs = method.TypeParameterList.Parameters.ToList();
// if (genericArgs.Count > 0)
// {
// writer.Write("( ");
// writer.Write(string.Join(" , ", genericArgs.Select(o => " " + o)));
// writer.Write(" )\r\n");
// }
if (genericArgs.Count > 0) // && !methodSymbol.ContainingType.IsGenericType) // doesnt matter
{
genericParameters += ("(");
genericParameters += (string.Join(",", genericArgs.Select(o => o)));
genericParameters += (")");
}
}
methodSignatureString += genericParameters;
var @params = GetParameterListAsString(method.ParameterList.Parameters,
iface: proxies == null ? iface : null, genericClass: virtualGenericClasses != null ? containingType : null);
// if (virtualGenericClasses != null)
// {
// @params = TypeProcessor.ConvertType() + ", " + @params;
// }
string constraints = GetMethodConstraints(method);
if (isInterface || method.Modifiers.Any(SyntaxKind.AbstractKeyword))
{
writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params + constraints + ";");
return;
}
writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params + constraints);
writer.OpenBrace();
if (isProxy)
{
@params = GetParameterListAsString(method.ParameterList.Parameters, includeTypes: false);
if (virtualGenericClasses != null)
{
/*
* public final static void Program_IBase_GenericVirtual_Dispatch(T)(Program.IBase aobj)
* {
* Object obj = cast(Object) aobj;
* if((typeid(obj)==typeid(Program.B)))
* (cast(Program.B)obj).GenericVirtual!(T)();
* if((typeid(obj)==typeid(Program.A)))
* (cast(Program.A)obj).GenericVirtual!(T)();
*
* }
*/
writer.WriteLine("NObject ___obj = cast(NObject)__obj;");
foreach (var virtualGenericClass in virtualGenericClasses)
{
var className = TypeProcessor.ConvertType(virtualGenericClass);
writer.WriteLine("if(typeid(___obj)==typeid({0}))", className);
if (method.ReturnType.ToString() == "void")
{
writer.WriteLine("(cast({0})___obj)." + originalMethodName + "!" + genericParameters + @params + ";", className);
}
else
{
writer.WriteLine("return (cast({0})___obj)." + methodSignatureString + "!" + genericParameters + ";", className);
}
}
}
else
{
if (method.ReturnType.ToString() == "void")
{
writer.WriteLine("__Value." + methodName + @params + ";");
}
else
{
writer.WriteLine("return __Value." + methodName + @params + ";");
}
}
}
else
{
if (!isProxy && isYield)
{
var namedTypeSymbol = methodSymbol.ReturnType as INamedTypeSymbol;
if (namedTypeSymbol != null)
{
// var iteratortype = namedTypeSymbol.TypeArguments[0];
var className = methodSymbol.GetYieldClassName() + (
(((INamedTypeSymbol)methodSymbol.ReturnType).TypeArguments.Any() && ((INamedTypeSymbol)methodSymbol.ReturnType).TypeArguments[0].TypeKind == TypeKind.TypeParameter) ? "__G" : "");
methodSignatureString = methodName + genericParameters;
if (!String.IsNullOrEmpty(genericParameters))
{
className = className + "!" + genericParameters;
}
var @params2 = GetParameterListAsString(method.ParameterList.Parameters, iface: methodSymbol.ContainingType);
var @params3 = GetParameterListAsString(method.ParameterList.Parameters, iface: null,
includeTypes: false, writebraces: false);
// writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params2 + constraints);
//writer.OpenBrace();
if (!methodSymbol.IsStatic)
{
if (method.ParameterList.Parameters.Count > 0)
{
writer.WriteLine("return new " + className + "(this," + @params3 + ");");
}
else
{
writer.WriteLine("return new " + className + "(this);");
}
}
else
{
writer.WriteLine("return new " + className + "(" + @params3 + ");");
}
}
}
else if (method.Body != null)
{
foreach (var statement in method.Body.Statements)
{
Core.Write(writer, statement);
}
TriviaProcessor.ProcessTrivias(writer, method.Body.DescendantTrivia());
}
if (pinvokeAttributes != null)
{
WritePInvokeMethodBody.Go(writer, methodName, methodSymbol, pinvokeAttributes);
}
if (isInternalPInvoke)
{
WritePInvokeMethodBody.Go(writer, methodName, methodSymbol, null);
}
if (!isProxy && isYield)
{
//writer.WriteLine("});");
}
}
writer.CloseBrace();
if (proxies != null)
{
foreach (var proxy in proxies)
{
//Need to write proxy signature here ...
methodSignatureString = methodName + genericParameters;
var @params2 = GetParameterListAsString(method.ParameterList.Parameters, iface: proxy.ContainingType);
var @params3 = GetParameterListAsString(method.ParameterList.Parameters, iface: null,
includeTypes: false);
writer.WriteLine(accessString + returnTypeString + methodSignatureString + @params2 + constraints);
writer.OpenBrace();
if (method.ReturnType.ToString() == "void")
{
writer.WriteLine("" + methodName + @params3 + ";");
}
else
{
writer.WriteLine("return " + methodName + @params3 + ";");
}
writer.CloseBrace();
}
}
}