private LuaInvocationExpressionSyntax BuildArray(ITypeSymbol elementType, IEnumerable <LuaExpressionSyntax> elements)
{
LuaExpressionSyntax baseType = GetTypeName(elementType);
var arrayType = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Array, baseType);
return(new LuaInvocationExpressionSyntax(arrayType, elements));
}
public override LuaSyntaxNode VisitTryStatement(TryStatementSyntax node)
{
LuaInvocationExpressionSyntax tryInvocationExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Try);
LuaTryAdapterExpressionSyntax tryBlockFunctionExpress = new LuaTryAdapterExpressionSyntax();
PushFunction(tryBlockFunctionExpress);
var block = (LuaBlockSyntax)node.Block.Accept(this);
PopFunction();
tryBlockFunctionExpress.AddStatements(block.Statements);
tryInvocationExpression.AddArgument(tryBlockFunctionExpress);
if (node.Catches.Count > 0)
{
var catchesExpress = VisitTryCatchesExpress(node.Catches);
tryInvocationExpression.AddArgument(catchesExpress);
}
else
{
tryInvocationExpression.AddArgument(LuaIdentifierNameSyntax.Nil);
}
if (node.Finally != null)
{
var finallyfunctionExpress = (LuaFunctionExpressionSyntax)node.Finally.Accept(this);
tryInvocationExpression.AddArgument(finallyfunctionExpress);
}
return(BuildCheckReturnInvocationExpression(tryInvocationExpression, node));
}
private void CheckValueTypeClone(ITypeSymbol typeSymbol, ref LuaExpressionSyntax expression) {
if (typeSymbol != null) {
if (typeSymbol.IsValueType && typeSymbol.TypeKind != TypeKind.Enum && typeSymbol.IsFromCode()) {
var invocation = new LuaInvocationExpressionSyntax(new LuaMemberAccessExpressionSyntax(expression, LuaIdentifierNameSyntax.Clone, true));
expression = invocation;
}
}
}
private LuaStatementSyntax BuildCheckReturnInvocationExpression(LuaInvocationExpressionSyntax invocationExpression, SyntaxNode node)
{
if (IsReturnExists(node))
{
var curMethodInfo = CurMethodInfoOrNull;
bool isReturnVoid = curMethodInfo != null && curMethodInfo.Symbol.ReturnsVoid;
var temp1 = GetTempIdentifier(node);
var temp2 = isReturnVoid ? null : GetTempIdentifier(node);
LuaLocalVariablesStatementSyntax localVariables = new LuaLocalVariablesStatementSyntax();
localVariables.Variables.Add(temp1);
if (temp2 != null)
{
localVariables.Variables.Add(temp2);
}
LuaEqualsValueClauseListSyntax initializer = new LuaEqualsValueClauseListSyntax();
initializer.Values.Add(invocationExpression);
localVariables.Initializer = initializer;
LuaIfStatementSyntax ifStatement = new LuaIfStatementSyntax(temp1);
if (CurFunction is LuaCheckReturnFunctionExpressionSyntax)
{
LuaMultipleReturnStatementSyntax returnStatement = new LuaMultipleReturnStatementSyntax();
returnStatement.Expressions.Add(LuaIdentifierNameSyntax.True);
if (temp2 != null)
{
returnStatement.Expressions.Add(temp2);
}
ifStatement.Body.Statements.Add(returnStatement);
}
else
{
if (curMethodInfo != null && curMethodInfo.RefOrOutParameters.Count > 0)
{
LuaMultipleReturnStatementSyntax returnStatement = new LuaMultipleReturnStatementSyntax();
if (temp2 != null)
{
returnStatement.Expressions.Add(temp2);
}
returnStatement.Expressions.AddRange(curMethodInfo.RefOrOutParameters);
ifStatement.Body.Statements.Add(returnStatement);
}
else
{
ifStatement.Body.Statements.Add(new LuaReturnStatementSyntax(temp2));
}
}
LuaStatementListSyntax statements = new LuaStatementListSyntax();
statements.Statements.Add(localVariables);
statements.Statements.Add(ifStatement);
return(statements);
}
else
{
return(new LuaExpressionStatementSyntax(invocationExpression));
}
}
public override LuaSyntaxNode VisitElementBindingExpression(ElementBindingExpressionSyntax node)
{
var argumentList = (LuaArgumentListSyntax)node.ArgumentList.Accept(this);
var memberAccess = new LuaMemberAccessExpressionSyntax(conditionalTemps_.Peek(), new LuaIdentifierNameSyntax(LuaSyntaxNode.Tokens.Get), true);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(memberAccess);
invocation.ArgumentList.Arguments.AddRange(argumentList.Arguments);
return(invocation);
}
public LuaExpressionSyntax Transpile(JassInvocationExpressionSyntax invocationExpression, out JassTypeSyntax type)
{
type = GetFunctionReturnType(invocationExpression.IdentifierName);
var luaInvocationExpression = new LuaInvocationExpressionSyntax(Transpile(invocationExpression.IdentifierName));
luaInvocationExpression.AddArguments(Transpile(invocationExpression.Arguments));
return(luaInvocationExpression);
}
public override LuaSyntaxNode VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
var arrayType = (LuaArrayTypeAdapterExpressionSyntax)node.Type.Accept(this);
if (node.Initializer != null && node.Initializer.Expressions.Count > 0)
{
if (arrayType.IsSimapleArray)
{
return(new LuaInvocationExpressionSyntax(arrayType, node.Initializer.Expressions.Select(i => (LuaExpressionSyntax)i.Accept(this))));
}
else
{
LuaTableInitializerExpression rankSpecifier = new LuaTableInitializerExpression();
LuaInvocationExpressionSyntax invocationExpression = new LuaInvocationExpressionSyntax(arrayType, rankSpecifier);
FillMultiArrayInitializer(node.Initializer, rankSpecifier, invocationExpression, true);
return(invocationExpression);
}
}
else
{
if (arrayType.IsSimapleArray)
{
var size = arrayType.RankSpecifier.Sizes[0];
if (size == null)
{
return(BuildEmptyArray(arrayType.BaseType));
}
var constSize = size as LuaLiteralExpressionSyntax;
if (constSize != null && constSize.Text == 0.ToString())
{
return(BuildEmptyArray(arrayType.BaseType));
}
LuaMemberAccessExpressionSyntax memberAccess = new LuaMemberAccessExpressionSyntax(arrayType, LuaIdentifierNameSyntax.New, true);
return(new LuaInvocationExpressionSyntax(memberAccess, size));
}
else
{
LuaTableInitializerExpression rankSpecifier = new LuaTableInitializerExpression();
foreach (var size in arrayType.RankSpecifier.Sizes)
{
if (size != null)
{
rankSpecifier.Items.Add(new LuaSingleTableItemSyntax(size));
}
else
{
rankSpecifier.Items.Add(new LuaSingleTableItemSyntax(new LuaIdentifierNameSyntax(0)));
}
}
return(new LuaInvocationExpressionSyntax(arrayType, rankSpecifier));
}
}
}
private LuaInvocationExpressionSyntax BuildObjectCreationInvocation(IMethodSymbol symbol, LuaExpressionSyntax expression) {
int constructorIndex = GetConstructorIndex(symbol);
if (constructorIndex > 0) {
expression = new LuaMemberAccessExpressionSyntax(expression, LuaIdentifierNameSyntax.New, true);
}
LuaInvocationExpressionSyntax invocationExpression = new LuaInvocationExpressionSyntax(expression);
if (constructorIndex > 0) {
invocationExpression.AddArgument(new LuaIdentifierNameSyntax(constructorIndex));
}
return invocationExpression;
}
private void ExportManifestFile(List <string> modules, string outFolder)
{
const string kDir = "dir";
const string kDirInitCode = "dir = (dir and #dir > 0) and (dir .. '.') or \"\"";
const string kRequire = "require";
const string kLoadCode = "local load = function(module) return require(dir .. module) end";
const string kLoad = "load";
const string kInit = "System.init";
const string kManifestFile = "manifest.lua";
if (modules.Count > 0)
{
modules.Sort();
var types = GetExportTypes();
if (types.Count > 0)
{
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(new LuaIdentifierNameSyntax(kDir));
functionExpression.AddStatement(new LuaIdentifierNameSyntax(kDirInitCode));
LuaIdentifierNameSyntax requireIdentifier = new LuaIdentifierNameSyntax(kRequire);
functionExpression.AddStatement(new LuaLocalVariableDeclaratorSyntax(requireIdentifier, requireIdentifier));
functionExpression.AddStatement(new LuaIdentifierNameSyntax(kLoadCode));
functionExpression.AddStatement(LuaBlankLinesStatement.One);
LuaIdentifierNameSyntax loadIdentifier = new LuaIdentifierNameSyntax(kLoad);
foreach (string module in modules)
{
var argument = new LuaStringLiteralExpressionSyntax(new LuaIdentifierNameSyntax(module));
var invocation = new LuaInvocationExpressionSyntax(loadIdentifier, argument);
functionExpression.AddStatement(invocation);
}
functionExpression.AddStatement(LuaBlankLinesStatement.One);
LuaTableInitializerExpression typeTable = new LuaTableInitializerExpression();
foreach (var type in types)
{
LuaIdentifierNameSyntax typeName = XmlMetaProvider.GetTypeShortName(type);
typeTable.Items.Add(new LuaSingleTableItemSyntax(new LuaStringLiteralExpressionSyntax(typeName)));
}
LuaInvocationExpressionSyntax initInvocation = new LuaInvocationExpressionSyntax(new LuaIdentifierNameSyntax(kInit), typeTable);
FillManifestInitConf(initInvocation);
functionExpression.AddStatement(initInvocation);
LuaCompilationUnitSyntax luaCompilationUnit = new LuaCompilationUnitSyntax();
luaCompilationUnit.Statements.Add(new LuaReturnStatementSyntax(functionExpression));
string outFile = Path.Combine(outFolder, kManifestFile);
Write(luaCompilationUnit, outFile);
}
}
}
public override LuaSyntaxNode VisitFromClause(FromClauseSyntax node)
{
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
if (node.Type != null)
{
var typeName = (LuaExpressionSyntax)node.Type.Accept(this);
expression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.LinqCast, expression, typeName);
}
return(expression);
}
private void TryAddStructDefaultMethod(INamedTypeSymbol symbol, LuaStructDeclarationSyntax declaration) {
if (declaration.IsInitStatementExists) {
LuaIdentifierNameSyntax className = new LuaIdentifierNameSyntax(symbol.Name);
var thisIdentifier = LuaIdentifierNameSyntax.This;
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(className);
var invocation = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.setmetatable, LuaTableInitializerExpression.Empty, className);
LuaLocalVariableDeclaratorSyntax local = new LuaLocalVariableDeclaratorSyntax(thisIdentifier, invocation);
functionExpression.AddStatement(local);
functionExpression.AddStatement(new LuaExpressionStatementSyntax(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Init, thisIdentifier)));
functionExpression.AddStatement(new LuaReturnStatementSyntax(thisIdentifier));
declaration.AddMethod(LuaIdentifierNameSyntax.Default, functionExpression, false);
}
}
public override LuaSyntaxNode VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var symbol = semanticModel_.GetTypeInfo(node.Initializer.Expressions.First()).Type;
LuaExpressionSyntax elementTypeExpression = GetTypeName(symbol);
LuaInvocationExpressionSyntax arrayTypeExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Array, elementTypeExpression);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(arrayTypeExpression);
foreach (var expression in node.Initializer.Expressions)
{
var element = (LuaExpressionSyntax)expression.Accept(this);
invocation.AddArgument(element);
}
return(invocation);
}
private LuaInvocationExpressionSyntax BuildCallBaseConstructor(ITypeSymbol baseType, int ctroCounter)
{
LuaInvocationExpressionSyntax otherCtorInvoke;
var typeName = GetTypeName(baseType);
LuaMemberAccessExpressionSyntax memberAccess = new LuaMemberAccessExpressionSyntax(typeName, LuaIdentifierNameSyntax.Ctor);
if (ctroCounter > 0)
{
otherCtorInvoke = new LuaInvocationExpressionSyntax(new LuaTableIndexAccessExpressionSyntax(memberAccess, new LuaIdentifierNameSyntax(ctroCounter)));
}
else
{
otherCtorInvoke = new LuaInvocationExpressionSyntax(memberAccess);
}
return(otherCtorInvoke);
}
public override LuaSyntaxNode VisitArrayType(ArrayTypeSyntax node)
{
var elementType = (LuaExpressionSyntax)node.ElementType.Accept(this);
LuaInvocationExpressionSyntax typeExpress = null;
foreach (var rank in node.RankSpecifiers.Reverse())
{
var arrayTypeName = rank.Rank == 1 ? LuaIdentifierNameSyntax.Array : LuaIdentifierNameSyntax.MultiArray;
typeExpress = new LuaInvocationExpressionSyntax(arrayTypeName, typeExpress ?? elementType);
}
var arrayRankSpecifier = (LuaArrayRankSpecifierSyntax)node.RankSpecifiers[0].Accept(this);
LuaArrayTypeAdapterExpressionSyntax arrayTypeAdapter = new LuaArrayTypeAdapterExpressionSyntax(typeExpress, arrayRankSpecifier);
return(arrayTypeAdapter);
}
public override LuaSyntaxNode VisitThrowStatement(ThrowStatementSyntax node)
{
LuaInvocationExpressionSyntax invocationExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Throw);
if (node.Expression != null)
{
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
invocationExpression.AddArgument(expression);
}
else
{
var curTryFunction = (LuaTryAdapterExpressionSyntax)CurFunction;
Contract.Assert(curTryFunction.CatchTemp != null);
invocationExpression.AddArgument(curTryFunction.CatchTemp);
}
return(new LuaExpressionStatementSyntax(invocationExpression));
}
private LuaFunctionExpressionSyntax BuildObjectInitializerExpression(InitializerExpressionSyntax node)
{
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
PushFunction(function);
var temp = GetTempIdentifier(node);
function.AddParameter(temp);
foreach (var expression in node.Expressions)
{
if (expression.IsKind(SyntaxKind.SimpleAssignmentExpression))
{
AssignmentExpressionSyntax assignment = (AssignmentExpressionSyntax)expression;
var left = assignment.Left.Accept(this);
var right = (LuaExpressionSyntax)assignment.Right.Accept(this);
CheckValueTypeAndConversion(assignment.Right, ref right);
if (assignment.Left.IsKind(SyntaxKind.ImplicitElementAccess))
{
var argumentList = (LuaArgumentListSyntax)left;
LuaIdentifierNameSyntax methodName = new LuaIdentifierNameSyntax(LuaSyntaxNode.Tokens.Set);
LuaMemberAccessExpressionSyntax memberAccess = new LuaMemberAccessExpressionSyntax(temp, methodName, true);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(memberAccess);
invocation.ArgumentList.Arguments.AddRange(argumentList.Arguments);
invocation.AddArgument(right);
function.AddStatement(invocation);
}
else
{
var memberAccess = BuildFieldOrPropertyMemberAccessExpression(temp, (LuaExpressionSyntax)left, false);
var assignmentExpression = BuildLuaSimpleAssignmentExpression(memberAccess, right);
function.AddStatement(assignmentExpression);
}
}
else
{
LuaMemberAccessExpressionSyntax memberAccess = new LuaMemberAccessExpressionSyntax(temp, LuaIdentifierNameSyntax.Add, true);
var value = (LuaExpressionSyntax)expression.Accept(this);
function.AddStatement(new LuaInvocationExpressionSyntax(memberAccess, value));
}
}
PopFunction();
return(function);
}
public override LuaSyntaxNode VisitUsingStatement(UsingStatementSyntax node)
{
List <LuaIdentifierNameSyntax> variableIdentifiers = new List <LuaIdentifierNameSyntax>();
List <LuaExpressionSyntax> variableExpressions = new List <LuaExpressionSyntax>();
if (node.Declaration != null)
{
var variableList = (LuaVariableListDeclarationSyntax)node.Declaration.Accept(this);
foreach (var variable in variableList.Variables)
{
variableIdentifiers.Add(variable.Identifier);
variableExpressions.Add(variable.Initializer.Value);
}
}
else
{
var expression = (LuaExpressionSyntax)node.Expression.Accept(this);
variableExpressions.Add(expression);
}
LuaUsingAdapterExpressionSyntax usingAdapterExpress = new LuaUsingAdapterExpressionSyntax();
usingAdapterExpress.ParameterList.Parameters.AddRange(variableIdentifiers.Select(i => new LuaParameterSyntax(i)));
PushFunction(usingAdapterExpress);
WriteStatementOrBlock(node.Statement, usingAdapterExpress.Body);
PopFunction();
if (variableExpressions.Count == 1)
{
LuaInvocationExpressionSyntax usingInvocationExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Using);
usingInvocationExpression.AddArgument(variableExpressions.First());
usingInvocationExpression.AddArgument(usingAdapterExpress);
return(BuildCheckReturnInvocationExpression(usingInvocationExpression, node));
}
else
{
LuaInvocationExpressionSyntax usingInvocationExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.UsingX);
usingInvocationExpression.AddArgument(usingAdapterExpress);
usingInvocationExpression.ArgumentList.Arguments.AddRange(variableExpressions.Select(i => new LuaArgumentSyntax(i)));
return(BuildCheckReturnInvocationExpression(usingInvocationExpression, node));
}
}
public LuaExpressionSyntax GetTypeName(ISymbol symbol, LuaSyntaxNodeTransfor transfor)
{
Contract.Assert(symbol != null);
if (symbol.Kind == SymbolKind.TypeParameter)
{
return(new LuaIdentifierNameSyntax(symbol.Name));
}
if (symbol.Kind == SymbolKind.ArrayType)
{
var arrayType = (IArrayTypeSymbol)symbol;
LuaExpressionSyntax elementTypeExpression = GetTypeName(arrayType.ElementType, transfor);
return(new LuaInvocationExpressionSyntax(arrayType.Rank == 1 ? LuaIdentifierNameSyntax.Array : LuaIdentifierNameSyntax.MultiArray, elementTypeExpression));
}
var namedTypeSymbol = (INamedTypeSymbol)symbol;
if (namedTypeSymbol.TypeKind == TypeKind.Enum)
{
return(LuaIdentifierNameSyntax.Int);
}
if (namedTypeSymbol.IsDelegateType())
{
return(LuaIdentifierNameSyntax.Delegate);
}
LuaIdentifierNameSyntax baseTypeName = GetTypeShortName(namedTypeSymbol, transfor);
var typeArguments = GetTypeArguments(namedTypeSymbol, transfor);
if (typeArguments.Count == 0)
{
return(baseTypeName);
}
else
{
var invocationExpression = new LuaInvocationExpressionSyntax(baseTypeName);
invocationExpression.AddArguments(typeArguments);
return(invocationExpression);
}
}
private void AddStructEqualsObjMethod(INamedTypeSymbol symbol, LuaStructDeclarationSyntax declaration, LuaExpressionSyntax typeName, List <LuaIdentifierNameSyntax> fields)
{
var thisIdentifier = LuaIdentifierNameSyntax.This;
LuaIdentifierNameSyntax obj = LuaIdentifierNameSyntax.Obj;
LuaFunctionExpressionSyntax functionExpression = new LuaFunctionExpressionSyntax();
functionExpression.AddParameter(thisIdentifier);
functionExpression.AddParameter(obj);
var left = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.getmetatable, obj);
LuaIfStatementSyntax ifStatement = new LuaIfStatementSyntax(new LuaBinaryExpressionSyntax(left, LuaSyntaxNode.Tokens.NotEquals, typeName));
ifStatement.Body.Statements.Add(new LuaReturnStatementSyntax(LuaIdentifierNameSyntax.False));
functionExpression.AddStatement(ifStatement);
if (fields.Count > 0)
{
var equalsStatic = LuaIdentifierNameSyntax.EqualsStatic;
LuaLocalVariableDeclaratorSyntax variableDeclarator = new LuaLocalVariableDeclaratorSyntax(equalsStatic, LuaIdentifierNameSyntax.SystemObjectEqualsStatic);
functionExpression.AddStatement(variableDeclarator);
LuaExpressionSyntax expression = null;
foreach (LuaIdentifierNameSyntax field in fields)
{
LuaMemberAccessExpressionSyntax argument1 = new LuaMemberAccessExpressionSyntax(thisIdentifier, field);
LuaMemberAccessExpressionSyntax argument2 = new LuaMemberAccessExpressionSyntax(obj, field);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(equalsStatic, argument1, argument2);
if (expression == null)
{
expression = invocation;
}
else
{
expression = new LuaBinaryExpressionSyntax(expression, LuaSyntaxNode.Tokens.And, invocation);
}
}
Contract.Assert(expression != null);
functionExpression.AddStatement(new LuaReturnStatementSyntax(expression));
}
declaration.AddMethod(LuaIdentifierNameSyntax.EqualsObj, functionExpression, false);
}
public override LuaSyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
{
var symbol = (IMethodSymbol)semanticModel_.GetSymbolInfo(node).Symbol;
LuaExpressionSyntax creationExpression;
if (symbol != null)
{
string codeTemplate = XmlMetaProvider.GetMethodCodeTemplate(symbol);
if (codeTemplate != null)
{
creationExpression = BuildCodeTemplateExpression(codeTemplate, null, node.ArgumentList.Arguments.Select(i => i.Expression), symbol.TypeArguments);
}
else
{
var expression = (LuaExpressionSyntax)node.Type.Accept(this);
var invokeExpression = BuildObjectCreationInvocation(symbol, expression);
var arguments = BuildArgumentList(symbol, symbol.Parameters, node.ArgumentList);
TryRemoveNilArgumentsAtTail(symbol, arguments);
invokeExpression.AddArguments(arguments);
creationExpression = invokeExpression;
}
}
else
{
Contract.Assert(!node.ArgumentList.Arguments.Any());
var expression = (LuaExpressionSyntax)node.Type.Accept(this);
var invokeExpression = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.SystemNew, expression);
creationExpression = invokeExpression;
}
if (node.Initializer == null)
{
return(creationExpression);
}
else
{
var functionExpression = BuildObjectInitializerExpression(node.Initializer);
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Create, creationExpression, functionExpression));
}
}
private void FillManifestInitConf(LuaInvocationExpressionSyntax invocation)
{
LuaTableInitializerExpression confTable = new LuaTableInitializerExpression();
if (mainEntryPoint_ != null)
{
LuaIdentifierNameSyntax methodName = new LuaIdentifierNameSyntax(mainEntryPoint_.Name);
var methodTypeName = XmlMetaProvider.GetTypeName(mainEntryPoint_.ContainingType, null);
var quote = new LuaIdentifierNameSyntax(LuaSyntaxNode.Tokens.Quote);
LuaCodeTemplateExpressionSyntax codeTemplate = new LuaCodeTemplateExpressionSyntax();
codeTemplate.Expressions.Add(quote);
codeTemplate.Expressions.Add(new LuaMemberAccessExpressionSyntax(methodTypeName, methodName));
codeTemplate.Expressions.Add(quote);
confTable.Items.Add(new LuaKeyValueTableItemSyntax(new LuaTableLiteralKeySyntax(methodName), codeTemplate));
}
if (confTable.Items.Count > 0)
{
invocation.AddArgument(confTable);
}
}
public override LuaSyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node)
{
Contract.Assert(node.IsKind(SyntaxKind.ArrayInitializerExpression));
var symbol = (IArrayTypeSymbol)semanticModel_.GetTypeInfo(node).ConvertedType;
if (node.Expressions.Count > 0)
{
LuaExpressionSyntax arrayType = GetTypeName(symbol);
LuaInvocationExpressionSyntax invocation = new LuaInvocationExpressionSyntax(arrayType);
foreach (var expression in node.Expressions)
{
var element = (LuaExpressionSyntax)expression.Accept(this);
invocation.AddArgument(element);
}
return(invocation);
}
else
{
LuaExpressionSyntax baseType = GetTypeName(symbol.ElementType);
return(BuildEmptyArray(baseType));
}
}
internal void Render(LuaInvocationExpressionSyntax node)
{
node.Expression.Render(this);
node.ArgumentList.Render(this);
}
public override LuaSyntaxNode VisitAttribute(AttributeSyntax node)
{
var symbol = (IMethodSymbol)semanticModel_.GetSymbolInfo(node.Name).Symbol;
INamedTypeSymbol typeSymbol = symbol.ContainingType;
if (!generator_.IsExportAttribute(typeSymbol))
{
return(null);
}
INamedTypeSymbol typeDeclarationSymbol = GetTypeDeclarationSymbol(node);
generator_.AddTypeDeclarationAttribute(typeDeclarationSymbol, typeSymbol);
++baseNameNodeCounter_;
var expression = GetTypeName(typeSymbol);
--baseNameNodeCounter_;
LuaInvocationExpressionSyntax invocation = BuildObjectCreationInvocation(symbol, new LuaMemberAccessExpressionSyntax(LuaIdentifierNameSyntax.Global, expression));
if (node.ArgumentList != null)
{
List <LuaExpressionSyntax> arguments = new List <LuaExpressionSyntax>();
List <Tuple <LuaExpressionSyntax, LuaExpressionSyntax> > initializers = new List <Tuple <LuaExpressionSyntax, LuaExpressionSyntax> >();
List <Tuple <NameColonSyntax, ExpressionSyntax> > argumentNodeInfos = new List <Tuple <NameColonSyntax, ExpressionSyntax> >();
foreach (var argumentNode in node.ArgumentList.Arguments)
{
var argumentExpression = (LuaExpressionSyntax)argumentNode.Expression.Accept(this);
CheckValueTypeAndConversion(argumentNode.Expression, ref argumentExpression);
if (argumentNode.NameEquals == null)
{
if (argumentNode.NameColon != null)
{
string name = argumentNode.NameColon.Name.Identifier.ValueText;
int index = symbol.Parameters.IndexOf(i => i.Name == name);
Contract.Assert(index != -1);
arguments.AddAt(index, argumentExpression);
}
else
{
arguments.Add(argumentExpression);
}
}
else
{
var name = (LuaExpressionSyntax)argumentNode.NameEquals.Accept(this);
initializers.Add(Tuple.Create(name, argumentExpression));
}
}
CheckInvocationDeafultArguments(symbol, symbol.Parameters, arguments, argumentNodeInfos, node, false);
invocation.AddArguments(arguments);
if (initializers.Count == 0)
{
return(invocation);
}
else
{
LuaFunctionExpressionSyntax function = new LuaFunctionExpressionSyntax();
PushFunction(function);
var temp = GetTempIdentifier(node);
function.AddParameter(temp);
foreach (var initializer in initializers)
{
var memberAccess = BuildFieldOrPropertyMemberAccessExpression(temp, initializer.Item1, false);
var assignmentExpression = BuildLuaSimpleAssignmentExpression(memberAccess, initializer.Item2);
function.AddStatement(assignmentExpression);
}
PopFunction();
return(new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Create, invocation, function));
}
}
else
{
return(invocation);
}
}
private LuaTryAdapterExpressionSyntax VisitTryCatchesExpress(SyntaxList <CatchClauseSyntax> catches)
{
LuaTryAdapterExpressionSyntax functionExpress = new LuaTryAdapterExpressionSyntax();
PushFunction(functionExpress);
var temp = GetTempIdentifier(catches.First());
functionExpress.CatchTemp = temp;
functionExpress.AddParameter(temp);
LuaIfStatementSyntax ifStatement = null;
bool hasCatchRoot = false;
foreach (var catchNode in catches)
{
bool isRootExceptionDeclaration = false;
LuaExpressionSyntax ifCondition = null;
if (catchNode.Filter != null)
{
ifCondition = (LuaExpressionSyntax)catchNode.Filter.Accept(this);
}
if (catchNode.Declaration != null)
{
var typeName = (LuaIdentifierNameSyntax)catchNode.Declaration.Type.Accept(this);
if (typeName.ValueText != "System.Exception")
{
var mathcTypeInvocation = new LuaInvocationExpressionSyntax(LuaIdentifierNameSyntax.Is, temp, typeName);
if (ifCondition != null)
{
ifCondition = new LuaBinaryExpressionSyntax(ifCondition, LuaSyntaxNode.Tokens.And, mathcTypeInvocation);
}
else
{
ifCondition = mathcTypeInvocation;
}
}
else
{
if (!catchNode.Declaration.Identifier.IsKind(SyntaxKind.None))
{
isRootExceptionDeclaration = true;
}
hasCatchRoot = true;
}
}
else
{
hasCatchRoot = true;
}
var block = (LuaBlockSyntax)catchNode.Block.Accept(this);
if (ifCondition != null)
{
LuaBlockSyntax body;
if (ifStatement == null)
{
ifStatement = new LuaIfStatementSyntax(ifCondition);
body = ifStatement.Body;
}
else
{
LuaElseIfStatementSyntax elseIfStatement = new LuaElseIfStatementSyntax(ifCondition);
body = elseIfStatement.Body;
ifStatement.ElseIfStatements.Add(elseIfStatement);
}
if (catchNode.Declaration != null && !catchNode.Declaration.Identifier.IsKind(SyntaxKind.None))
{
var variableDeclarator = (LuaVariableDeclaratorSyntax)catchNode.Declaration.Accept(this);
variableDeclarator.Initializer = new LuaEqualsValueClauseSyntax(temp);
body.Statements.Add(new LuaLocalVariableDeclaratorSyntax(variableDeclarator));
}
body.Statements.AddRange(block.Statements);
}
else
{
if (isRootExceptionDeclaration)
{
var variableDeclarator = (LuaVariableDeclaratorSyntax)catchNode.Declaration.Accept(this);
variableDeclarator.Initializer = new LuaEqualsValueClauseSyntax(temp);
block.Statements.Insert(0, new LuaLocalVariableDeclaratorSyntax(variableDeclarator));
}
if (ifStatement != null)
{
LuaElseClauseSyntax elseClause = new LuaElseClauseSyntax();
elseClause.Body.Statements.AddRange(block.Statements);
ifStatement.Else = elseClause;
}
else
{
functionExpress.AddStatements(block.Statements);
}
break;
}
}
if (ifStatement != null)
{
if (!hasCatchRoot)
{
Contract.Assert(ifStatement.Else == null);
LuaMultipleReturnStatementSyntax rethrowStatement = new LuaMultipleReturnStatementSyntax();
rethrowStatement.Expressions.Add(LuaIdentifierNameSyntax.One);
rethrowStatement.Expressions.Add(temp);
LuaBlockSyntax block = new LuaBlockSyntax();
block.Statements.Add(rethrowStatement);
LuaElseClauseSyntax elseClause = new LuaElseClauseSyntax();
elseClause.Body.Statements.AddRange(block.Statements);
ifStatement.Else = elseClause;
}
functionExpress.AddStatement(ifStatement);
}
PopFunction();
return(functionExpress);
}
public override LuaSyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
{
IMethodSymbol ctorSymbol = semanticModel_.GetDeclaredSymbol(node);
methodInfos_.Push(new MethodInfo(ctorSymbol));
LuaConstructorAdapterExpressionSyntax function = new LuaConstructorAdapterExpressionSyntax();
PushFunction(function);
bool isStatic = node.Modifiers.IsStatic();
function.AddParameter(LuaIdentifierNameSyntax.This);
var parameterList = (LuaParameterListSyntax)node.ParameterList.Accept(this);
function.ParameterList.Parameters.AddRange(parameterList.Parameters);
if (node.Initializer != null)
{
var symbol = (IMethodSymbol)semanticModel_.GetSymbolInfo(node.Initializer).Symbol;
int ctroCounter = GetConstructorIndex(symbol);
LuaInvocationExpressionSyntax otherCtorInvoke;
if (node.Initializer.IsKind(SyntaxKind.ThisConstructorInitializer))
{
Contract.Assert(ctroCounter != 0);
LuaIdentifierNameSyntax thisCtor = new LuaIdentifierNameSyntax(LuaSyntaxNode.SpecailWord(LuaSyntaxNode.Tokens.Ctor + ctroCounter));
otherCtorInvoke = new LuaInvocationExpressionSyntax(thisCtor);
function.IsInvokeThisCtor = true;
}
else
{
otherCtorInvoke = BuildCallBaseConstructor(symbol.ReceiverType, ctroCounter);
}
otherCtorInvoke.AddArgument(LuaIdentifierNameSyntax.This);
var arguments = BuildArgumentList(symbol, symbol.Parameters, node.Initializer.ArgumentList);
otherCtorInvoke.AddArguments(arguments);
function.AddStatement(otherCtorInvoke);
}
else if (!isStatic)
{
var baseCtorInvoke = BuildCallBaseConstructor(ctorSymbol.ContainingType);
if (baseCtorInvoke != null)
{
function.AddStatement(baseCtorInvoke);
}
}
LuaBlockSyntax block = (LuaBlockSyntax)node.Body.Accept(this);
function.AddStatements(block.Statements);
PopFunction();
if (isStatic)
{
CurType.SetStaticCtor(function);
}
else
{
CurType.AddCtor(function, node.ParameterList.Parameters.Count == 0);
}
methodInfos_.Pop();
return(function);
}
private void FillMultiArrayInitializer(InitializerExpressionSyntax initializer, LuaTableInitializerExpression rankSpecifier, LuaInvocationExpressionSyntax invocation, bool isFirst)
{
if (isFirst)
{
rankSpecifier.Items.Add(new LuaSingleTableItemSyntax(new LuaIdentifierNameSyntax(initializer.Expressions.Count)));
}
int index = 0;
foreach (var expression in initializer.Expressions)
{
if (expression.IsKind(SyntaxKind.ArrayInitializerExpression))
{
FillMultiArrayInitializer((InitializerExpressionSyntax)expression, rankSpecifier, invocation, index == 0);
}
else
{
var item = (LuaExpressionSyntax)expression.Accept(this);
invocation.AddArgument(item);
}
++index;
}
}
