private static void Factory(HaxeWriter writer, SyntaxNode node)
{
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 FieldDeclarationSyntax)
{
WriteField.Go(writer, node.As <FieldDeclarationSyntax>());
}
else if (node is ConstructorDeclarationSyntax)
{
WriteConstructor.Go(writer, node.As <ConstructorDeclarationSyntax>());
}
else if (node is ExpressionStatementSyntax)
{
WriteStatement(writer, node.As <ExpressionStatementSyntax>());
}
else if (node is LocalDeclarationStatementSyntax)
{
WriteLocalDeclaration.Go(writer, node.As <LocalDeclarationStatementSyntax>());
}
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>());
}
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 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 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 ThrowExpressionSyntax)
{
WriteThrowStatement.GoExpression(writer, node.As <ThrowExpressionSyntax>());
}
else if (node is PrefixUnaryExpressionSyntax)
{
WriteUnaryExpression.Go(writer, node.As <PrefixUnaryExpressionSyntax>());
}
else if (node is PostfixUnaryExpressionSyntax)
{
WriteUnaryExpression.Go(writer, node.As <PostfixUnaryExpressionSyntax>());
}
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 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 ContinueStatementSyntax)
{
WriteContinueStatement.Go(writer, node.As <ContinueStatementSyntax>());
}
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 - we convert them to types directly
}
else if (node is EventFieldDeclarationSyntax)
{
WriteEventFieldDeclaration.Go(writer, node.As <EventFieldDeclarationSyntax>());
}
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 AssignmentExpressionSyntax)
{
WriteAssignmentExpressionSyntax.Go(writer, node.As <AssignmentExpressionSyntax>());
}
else if (node is OperatorDeclarationSyntax)
{
WriteMethod.WriteOperatorDeclaration(writer, node.As <OperatorDeclarationSyntax>());
}
else if (node is IndexerDeclarationSyntax)
{
WriteMethod.WriteIndexerDeclaration(writer, node.As <IndexerDeclarationSyntax>());
}
else
{
throw new NotImplementedException(node.GetType().Name + " is not supported. " + Utility.Descriptor(node));
}
}
public static void Go(HaxeWriter writer, InvocationExpressionSyntax invocationExpression)
{
var model = Program.GetModel(invocationExpression);
var symbolInfo = model.GetSymbolInfo(invocationExpression);
var expressionSymbol = model.GetSymbolInfo(invocationExpression.Expression);
if (symbolInfo.Symbol == null)
{
throw new Exception("InvocationExpression could not be identified. Are you sure the C# is valid? " + Utility.Descriptor(invocationExpression));
}
var methodSymbol = (IMethodSymbol)symbolInfo.Symbol;
var origMethodSymbol = methodSymbol.OriginalDefinition.As <IMethodSymbol>().UnReduce();
var translateOpt = MethodTranslation.Get(symbolInfo.Symbol.As <IMethodSymbol>());
var memberReferenceExpressionOpt = invocationExpression.Expression as MemberAccessExpressionSyntax;
//var returnTypeHaxe = TypeProcessor.ConvertType(methodSymbol.ReturnType);
var firstParameter = true;
if (methodSymbol.TypeArguments.Any(o => o.SpecialType == SpecialType.System_Char) && origMethodSymbol.ContainingType.Name != "Enumerable")
{
throw new Exception("Char cannot be passed as a type argument. methodName=" + origMethodSymbol.Name + " " + Utility.Descriptor(invocationExpression)); //the called function could call .ToString on it, which would give the int representation instead of the char. We could fix this by wrapping chars in a class but that would hit performance, so instead just re-write the offending C#. Skip this requirement for System.Linq.Enumerable because it is typically just mapping to a lambda, such as Select or TakeWhile, and our lambda can handle it correctly. Ideally we'd detect if the type parameter is only used in a lambda
}
var extensionNamespace = origMethodSymbol.IsExtensionMethod ? origMethodSymbol.ContainingNamespace.FullNameWithDot().ToLower() + origMethodSymbol.ContainingType.Name : null; //null means it's not an extension method, non-null means it is
string methodName;
ExpressionSyntax subExpressionOpt;
if (origMethodSymbol.ContainingType.Name == "Enum")
{
if (origMethodSymbol.Name == "Parse")
{
WriteEnumParse(writer, invocationExpression);
return;
}
if (origMethodSymbol.Name == "GetValues")
{
WriteEnumGetValues(writer, invocationExpression);
return;
}
}
if (expressionSymbol.Symbol is IEventSymbol)
{
methodName = "Invoke"; //Would need to append the number of arguments to this to support events. However, events are not currently supported
}
else if (memberReferenceExpressionOpt != null && memberReferenceExpressionOpt.Expression is PredefinedTypeSyntax)
{
switch (origMethodSymbol.Name)
{
case "Parse":
var t = TypeProcessor.ConvertType(origMethodSymbol.ReturnType);
if (t == "Bool")
{
methodName = "ParseBool";
extensionNamespace = "Cs2Hx";
}
else if (t == "Int" || t == "Float")
{
methodName = "parse" + t;
extensionNamespace = "Std";
}
else
{
throw new Exception("Parse method on " + t + " is not supported. " + Utility.Descriptor(memberReferenceExpressionOpt));
}
break;
case "TryParse":
methodName = "TryParse" + TypeProcessor.ConvertType(origMethodSymbol.Parameters[1].Type);
extensionNamespace = "Cs2Hx";
break;
default:
methodName = origMethodSymbol.Name;
extensionNamespace = "Cs2Hx";
break;
}
}
else if (translateOpt != null && translateOpt.ReplaceWith != null)
{
methodName = translateOpt.ReplaceWith;
}
else if (origMethodSymbol.MethodKind == MethodKind.DelegateInvoke)
{
methodName = null;
}
else
{
methodName = OverloadResolver.MethodName(origMethodSymbol);
}
if (translateOpt != null && translateOpt.HasComplexReplaceWith)
{
translateOpt.DoComplexReplaceWith(writer, memberReferenceExpressionOpt); //TODO: What if this is null?
return;
}
if (translateOpt != null && translateOpt.SkipExtensionParameter)
{
subExpressionOpt = null;
}
else if (origMethodSymbol.MethodKind == MethodKind.DelegateInvoke)
{
subExpressionOpt = invocationExpression.Expression;
}
else if (memberReferenceExpressionOpt != null)
{
if (memberReferenceExpressionOpt.Expression is PredefinedTypeSyntax)
{
subExpressionOpt = null;
}
else
{
subExpressionOpt = memberReferenceExpressionOpt.Expression;
}
}
else
{
subExpressionOpt = null; //TODO
}
//Determine if it's an extension method called in a non-extension way. In this case, just pretend it's not an extension method
if (extensionNamespace != null && subExpressionOpt != null && model.GetTypeInfo(subExpressionOpt).ConvertedType.ToString() == origMethodSymbol.ContainingNamespace + "." + origMethodSymbol.ContainingType.Name)
{
extensionNamespace = null;
}
if (translateOpt != null && !string.IsNullOrEmpty(translateOpt.ExtensionNamespace))
{
extensionNamespace = translateOpt.ExtensionNamespace;
}
else if (translateOpt != null && translateOpt.ExtensionNamespace == "")
{
extensionNamespace = null;
}
if (extensionNamespace != null)
{
writer.Write(extensionNamespace);
if (methodName != null)
{
writer.Write(".");
writer.Write(methodName);
}
writer.Write("(");
if (subExpressionOpt != null)
{
firstParameter = false;
if (origMethodSymbol.IsExtensionMethod)
{
WriteForEachStatement.CheckWriteEnumerator(writer, subExpressionOpt, true);
}
else
{
Core.Write(writer, subExpressionOpt);
}
}
}
else
{
if (memberReferenceExpressionOpt != null)
{
var memberType = model.GetTypeInfo(memberReferenceExpressionOpt.Expression).Type;
var memberTypeHaxe = TypeProcessor.ConvertType(memberType);
//sort calls without any parameters need to get the default sort parameter
if (methodName == "sort" && invocationExpression.ArgumentList.Arguments.Count == 0)
{
Core.Write(writer, memberReferenceExpressionOpt.Expression);
writer.Write(".sort(");
switch (memberTypeHaxe)
{
case "Array<Int>":
writer.Write("Cs2Hx.SortInts");
break;
case "Array<Float>":
writer.Write("Cs2Hx.SortFloats");
break;
case "Array<String>":
writer.Write("Cs2Hx.SortStrings");
break;
default:
throw new Exception("Unknown default sort type: " + memberTypeHaxe + ". " + Utility.Descriptor(invocationExpression));
}
writer.Write(")");
return;
}
//Check against lowercase toString since it gets replaced with the haxe name before we get here
if (methodName == "toString")
{
if (memberType.TypeKind == TypeKind.Enum)
{
//calling ToString() on an enum forwards to our enum's special ToString method
writer.Write(memberType.ContainingNamespace.FullNameWithDot().ToLower());
writer.Write(WriteType.TypeName((INamedTypeSymbol)memberType));
writer.Write(".ToString(");
Core.Write(writer, memberReferenceExpressionOpt.Expression);
writer.Write(")");
if (invocationExpression.ArgumentList.Arguments.Count > 0)
{
throw new Exception("Enum's ToString detected with parameters. These are not supported " + Utility.Descriptor(invocationExpression));
}
return;
}
if (memberType.SpecialType == SpecialType.System_Char)
{
writer.Write("Cs2Hx.CharToString(");
Core.Write(writer, memberReferenceExpressionOpt.Expression);
writer.Write(")");
if (invocationExpression.ArgumentList.Arguments.Count > 0)
{
throw new Exception("Char's ToString detected with parameters. These are not supported " + Utility.Descriptor(invocationExpression));
}
return;
}
if (memberTypeHaxe == "Int" || memberTypeHaxe == "Float" || memberTypeHaxe == "Bool" || memberType.TypeKind == TypeKind.TypeParameter)
{
//ToString()'s on primitive types get replaced with Std.string
writer.Write("Std.string(");
if (memberReferenceExpressionOpt.Expression is ParenthesizedExpressionSyntax)
{
Core.Write(writer, memberReferenceExpressionOpt.Expression.As <ParenthesizedExpressionSyntax>().Expression); //eat a set of parenthesis, just to make the output code a bit nicer.
}
else
{
Core.Write(writer, memberReferenceExpressionOpt.Expression);
}
writer.Write(")");
if (invocationExpression.ArgumentList.Arguments.Count > 0)
{
throw new Exception("Primitive type's ToString detected with parameters. These are not supported " + Utility.Descriptor(invocationExpression));
}
return; //Skip parameters
}
}
}
if (subExpressionOpt != null)
{
WriteMemberAccessExpression.WriteMember(writer, subExpressionOpt);
}
if (subExpressionOpt != null && methodName != null)
{
writer.Write(".");
}
writer.Write(methodName);
writer.Write("(");
}
var prms = TranslateParameters(translateOpt, SortArguments(origMethodSymbol, invocationExpression.ArgumentList.Arguments, invocationExpression, extensionNamespace != null), invocationExpression).ToList();
//If we invoke a method with type parameters that aren't used in the argument list, the haxe function won't have a way to see what args were used. To give it a way, add those as parameters at the end
foreach (var typePrm in Utility.PassTypeArgsToMethod(origMethodSymbol))
{
var name = invocationExpression.Expression.ChildNodes().OfType <GenericNameSyntax>().ToList();
if (name.Count == 0)
{
name = invocationExpression.Expression.DescendantNodesAndSelf().OfType <GenericNameSyntax>().ToList(); //TODO: This will pick up false positives, we need a proper recursion function here
}
if (name.Count != 1)
{
throw new Exception("Expected a single generic name, got " + string.Join(", ", name) + " " + Utility.Descriptor(invocationExpression));
}
if (name.Count > 0 && name.Single().TypeArgumentList.Arguments.Count > 0)
{
var typePrmIndex = origMethodSymbol.TypeParameters.IndexOf(origMethodSymbol.TypeParameters.Single(o => SymbolEqualityComparer.Default.Equals(o, typePrm)));
var genericVar = name.Single().TypeArgumentList.Arguments.ElementAt(typePrmIndex);
if (genericVar.ToString() == typePrm.ToString())
{
writer.Write("t" + (typePrmIndex + 1));
}
else
{
prms.Add(new TransformedArgument(TypeProcessor.ConvertType(genericVar)));
}
}
}
bool inParams = false;
foreach (var arg in prms)
{
if (firstParameter)
{
firstParameter = false;
}
else
{
writer.Write(", ");
}
if (!inParams && IsParamsArgument(invocationExpression, arg.ArgumentOpt, origMethodSymbol) && TypeProcessor.ConvertType(model.GetTypeInfo(arg.ArgumentOpt.Expression).Type).StartsWith("Array<") == false)
{
inParams = true;
writer.Write("[ ");
}
if (arg.ArgumentOpt != null &&
arg.ArgumentOpt.RefOrOutKeyword.Kind() != SyntaxKind.None &&
model.GetSymbolInfo(arg.ArgumentOpt.Expression).Symbol is IFieldSymbol)
{
throw new Exception("ref/out cannot reference fields, only local variables. Consider using ref/out on a local variable and then assigning it into the field. " + Utility.Descriptor(invocationExpression));
}
//When passing an argument by ref or out, leave off the .Value suffix
if (arg.ArgumentOpt != null && arg.ArgumentOpt.RefOrOutKeyword.Kind() != SyntaxKind.None)
{
WriteIdentifierName.Go(writer, arg.ArgumentOpt.Expression.As <IdentifierNameSyntax>(), true);
}
else if (arg.ArgumentOpt != null)
{
WriteForEachStatement.CheckWriteEnumerator(writer, arg.ArgumentOpt.Expression, false);
}
else
{
arg.Write(writer);
}
}
if (inParams)
{
writer.Write(" ]");
}
writer.Write(")");
}
public static void Go(HaxeWriter writer, InvocationExpressionSyntax invocationExpression)
{
var model = Program.GetModel(invocationExpression);
var symbolInfo = model.GetSymbolInfo(invocationExpression);
var expressionSymbol = model.GetSymbolInfo(invocationExpression.Expression);
var methodSymbol = symbolInfo.Symbol.OriginalDefinition.As <IMethodSymbol>().UnReduce();
var translateOpt = MethodTranslation.Get(symbolInfo.Symbol.As <IMethodSymbol>());
var memberReferenceExpressionOpt = invocationExpression.Expression as MemberAccessExpressionSyntax;
var returnTypeHaxe = TypeProcessor.ConvertType(methodSymbol.ReturnType);
var firstParameter = true;
var extensionNamespace = methodSymbol.IsExtensionMethod ? methodSymbol.ContainingNamespace.FullNameWithDot().ToLower() + methodSymbol.ContainingType.Name : null; //null means it's not an extension method, non-null means it is
string methodName;
ExpressionSyntax subExpressionOpt;
if (methodSymbol.ContainingType.Name == "Enum")
{
if (methodSymbol.Name == "Parse")
{
WriteEnumParse(writer, invocationExpression);
return;
}
if (methodSymbol.Name == "GetValues")
{
WriteEnumGetValues(writer, invocationExpression);
return;
}
}
if (expressionSymbol.Symbol is IEventSymbol)
{
methodName = "Invoke"; //Would need to append the number of arguments to this to support events. However, events are not currently supported
}
else if (memberReferenceExpressionOpt != null && memberReferenceExpressionOpt.Expression is PredefinedTypeSyntax)
{
switch (methodSymbol.Name)
{
case "Parse":
var t = TypeProcessor.ConvertType(methodSymbol.ReturnType);
if (t == "Bool")
{
methodName = "ParseBool";
extensionNamespace = "Cs2Hx";
}
else if (t == "Int" || t == "Float")
{
methodName = "parse" + t;
extensionNamespace = "Std";
}
else
{
throw new Exception("Parse method on " + t + " is not supported. " + Utility.Descriptor(memberReferenceExpressionOpt));
}
break;
case "TryParse":
methodName = "TryParse" + TypeProcessor.ConvertType(methodSymbol.Parameters[1].Type);
extensionNamespace = "Cs2Hx";
break;
default:
methodName = methodSymbol.Name;
extensionNamespace = "Cs2Hx";
break;
}
}
else if (translateOpt != null && translateOpt.ReplaceWith != null)
{
methodName = translateOpt.ReplaceWith;
}
else if (methodSymbol.MethodKind == MethodKind.DelegateInvoke)
{
methodName = null;
}
else
{
methodName = OverloadResolver.MethodName(methodSymbol);
}
if (translateOpt != null && translateOpt.HasComplexReplaceWith)
{
translateOpt.DoComplexReplaceWith(writer, memberReferenceExpressionOpt); //TODO: What if this is null?
return;
}
if (translateOpt != null && translateOpt.SkipExtensionParameter)
{
subExpressionOpt = null;
}
else if (methodSymbol.MethodKind == MethodKind.DelegateInvoke)
{
subExpressionOpt = invocationExpression.Expression;
}
else if (memberReferenceExpressionOpt != null)
{
if (memberReferenceExpressionOpt.Expression is PredefinedTypeSyntax)
{
subExpressionOpt = null;
}
else
{
subExpressionOpt = memberReferenceExpressionOpt.Expression;
}
}
else
{
subExpressionOpt = null; //TODO
}
//Determine if it's an extension method called in a non-extension way. In this case, just pretend it's not an extension method
if (extensionNamespace != null && subExpressionOpt != null && model.GetTypeInfo(subExpressionOpt).ConvertedType.ToString() == methodSymbol.ContainingNamespace + "." + methodSymbol.ContainingType.Name)
{
extensionNamespace = null;
}
if (translateOpt != null && !string.IsNullOrEmpty(translateOpt.ExtensionNamespace))
{
extensionNamespace = translateOpt.ExtensionNamespace;
}
else if (translateOpt != null && translateOpt.ExtensionNamespace == "")
{
extensionNamespace = null;
}
if (extensionNamespace != null)
{
writer.Write(extensionNamespace);
if (methodName != null)
{
writer.Write(".");
writer.Write(methodName);
}
writer.Write("(");
if (subExpressionOpt != null)
{
firstParameter = false;
if (methodSymbol.IsExtensionMethod)
{
WriteForEachStatement.CheckWriteEnumerator(writer, subExpressionOpt, true);
}
else
{
Core.Write(writer, subExpressionOpt);
}
}
}
else
{
if (memberReferenceExpressionOpt != null)
{
var memberType = model.GetTypeInfo(memberReferenceExpressionOpt.Expression).Type;
var memberTypeHaxe = TypeProcessor.ConvertType(memberType);
//sort calls without any parameters need to get the default sort parameter
if (methodName == "sort" && invocationExpression.ArgumentList.Arguments.Count == 0)
{
Core.Write(writer, memberReferenceExpressionOpt.Expression);
writer.Write(".sort(");
switch (memberTypeHaxe)
{
case "Array<Int>":
writer.Write("Cs2Hx.SortInts");
break;
case "Array<Float>":
writer.Write("Cs2Hx.SortFloats");
break;
case "Array<String>":
writer.Write("Cs2Hx.SortStrings");
break;
default:
throw new Exception("Unknown default sort type: " + memberTypeHaxe + ". " + Utility.Descriptor(invocationExpression));
}
writer.Write(")");
return;
}
//Check against lowercase toString since it gets replaced with the haxe name before we get here
if (methodName == "toString")
{
if (memberType.TypeKind == TypeKind.Enum)
{
//calling ToString() on an enum forwards to our enum's special ToString method
writer.Write(memberType.ContainingNamespace.FullNameWithDot().ToLower());
writer.Write(WriteType.TypeName((INamedTypeSymbol)memberType));
writer.Write(".ToString(");
Core.Write(writer, memberReferenceExpressionOpt.Expression);
writer.Write(")");
if (invocationExpression.ArgumentList.Arguments.Count > 0)
{
throw new Exception("Enum's ToString detected with parameters. These are not supported " + Utility.Descriptor(invocationExpression));
}
return;
}
if (memberType.SpecialType == SpecialType.System_Char)
{
writer.Write("Cs2Hx.CharToString(");
Core.Write(writer, memberReferenceExpressionOpt.Expression);
writer.Write(")");
if (invocationExpression.ArgumentList.Arguments.Count > 0)
{
throw new Exception("Char's ToString detected with parameters. These are not supported " + Utility.Descriptor(invocationExpression));
}
return;
}
if (memberTypeHaxe == "Int" || memberTypeHaxe == "Float" || memberTypeHaxe == "Bool" || memberType.TypeKind == TypeKind.TypeParameter)
{
//ToString()'s on primitive types get replaced with Std.string
writer.Write("Std.string(");
if (memberReferenceExpressionOpt.Expression is ParenthesizedExpressionSyntax)
{
Core.Write(writer, memberReferenceExpressionOpt.Expression.As <ParenthesizedExpressionSyntax>().Expression); //eat a set of parenthesis, just to make the output code a bit nicer.
}
else
{
Core.Write(writer, memberReferenceExpressionOpt.Expression);
}
writer.Write(")");
if (invocationExpression.ArgumentList.Arguments.Count > 0)
{
throw new Exception("Primitive type's ToString detected with parameters. These are not supported " + Utility.Descriptor(invocationExpression));
}
return; //Skip parameters
}
}
}
if (subExpressionOpt != null)
{
WriteMemberAccessExpression.WriteMember(writer, subExpressionOpt);
}
if (subExpressionOpt != null && methodName != null)
{
writer.Write(".");
}
writer.Write(methodName);
writer.Write("(");
}
bool inParams = false;
foreach (var arg in TranslateParameters(translateOpt, SortArguments(methodSymbol, invocationExpression.ArgumentList.Arguments, invocationExpression), invocationExpression))
{
if (firstParameter)
{
firstParameter = false;
}
else
{
writer.Write(", ");
}
if (!inParams && IsParamsArgument(invocationExpression, arg.ArgumentOpt, methodSymbol) && TypeProcessor.ConvertType(model.GetTypeInfo(arg.ArgumentOpt.Expression).Type).StartsWith("Array<") == false)
{
inParams = true;
writer.Write("[ ");
}
if (arg.ArgumentOpt != null &&
arg.ArgumentOpt.RefOrOutKeyword.Kind() != SyntaxKind.None &&
model.GetSymbolInfo(arg.ArgumentOpt.Expression).Symbol is IFieldSymbol)
{
throw new Exception("ref/out cannot reference fields, only local variables. Consider using ref/out on a local variable and then assigning it into the field. " + Utility.Descriptor(invocationExpression));
}
//When passing an argument by ref or out, leave off the .Value suffix
if (arg.ArgumentOpt != null && arg.ArgumentOpt.RefOrOutKeyword.Kind() != SyntaxKind.None)
{
WriteIdentifierName.Go(writer, arg.ArgumentOpt.Expression.As <IdentifierNameSyntax>(), true);
}
else if (arg.ArgumentOpt != null)
{
WriteForEachStatement.CheckWriteEnumerator(writer, arg.ArgumentOpt.Expression, false);
}
else
{
arg.Write(writer);
}
}
if (inParams)
{
writer.Write(" ]");
}
writer.Write(")");
}
