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; } }