private string GenerateForEachStatement(ForEachStatementSyntax forEachStatementSyntax, SemanticModel semanticModel)
{
string variable = forEachStatementSyntax.Identifier.ValueText;
var symbolInfo = semanticModel.GetSymbolInfo(forEachStatementSyntax.Type);
string variableTypeText;
if (symbolInfo.Symbol is INamedTypeSymbol)
{
var namedTypeSymbol = symbolInfo.Symbol as INamedTypeSymbol;
var typeReference = TypeReferenceGenerator.GenerateTypeReference(namedTypeSymbol, semanticModel);
variableTypeText = typeReference.Text;
}
else if (symbolInfo.Symbol is ITypeParameterSymbol)
{
variableTypeText = (symbolInfo.Symbol as ITypeParameterSymbol).Name;
}
else
{
throw new NotImplementedException();
}
string iterable = ExpressionGenerator.GenerateExpression(forEachStatementSyntax.Expression, semanticModel);
string jStatements;
if (!(forEachStatementSyntax.Statement is BlockSyntax))
{
jStatements = Generate(forEachStatementSyntax.Statement, semanticModel);
}
else
{
jStatements = GenerateBlock(forEachStatementSyntax.Statement as BlockSyntax, semanticModel);
}
return("for (" + variableTypeText + " " + variable + " : " + iterable + ") {\n"
+ " " + jStatements + "\n"
+ "}");
}
private SourceCode GetConstructors(SemanticModel semanticModel, HashSet <string> typeReferences, IEnumerable <ConstructorDeclarationSyntax> constructorDeclarations)
{
var generatedConstructors = new SourceCode {
MainPart = ""
};
foreach (var constructorDeclaration in constructorDeclarations)
{
string identifier = constructorDeclaration.Identifier.ValueText;
var parameters = new List <Var>();
foreach (var parameter in constructorDeclaration.ParameterList.Parameters)
{
var typeReference = TypeReferenceGenerator.GenerateTypeReference(parameter.Type, semanticModel);
parameters.Add(new Var
{
Name = parameter.Identifier.ValueText,
Type = typeReference
});
}
var constructorAccessModifier = GetAccessModifier(constructorDeclaration.Modifiers.ToList());
var statements = new List <string>();
foreach (var statement in constructorDeclaration.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
}
var generatedConstructor = ConstructorGenerator.Generate(identifier, constructorAccessModifier, parameters,
statements, semanticModel);
generatedConstructors.MainPart += "\n" + generatedConstructor.MainPart;
}
return(generatedConstructors);
}
private string GenerateObjectCreationExpression(ObjectCreationExpressionSyntax objectCreationExpressionSyntax, SemanticModel semanticModel)
{
var type = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, objectCreationExpressionSyntax).Type;
if (IsExceptionType(type))
{
return(GenerateExceptionCreationExpression(objectCreationExpressionSyntax, semanticModel));
}
string typeReference = TypeReferenceGenerator.GenerateTypeReference(type, semanticModel).Text;
string argumentList = ArgumentListGenerator.Generate(objectCreationExpressionSyntax.ArgumentList, semanticModel);
string constructorCall = "new " + typeReference + argumentList;
var initializer = objectCreationExpressionSyntax.Initializer;
if (initializer == null || !initializer.Expressions.Any())
{
return(constructorCall);
}
else
{
string objectToCreateName = "temp";
string initializations = "";
var expressions = objectCreationExpressionSyntax.Initializer.Expressions;
foreach (var expressionSyntax in expressions)
{
if (expressionSyntax is AssignmentExpressionSyntax)
{
var assignmentExpressionSyntax = expressionSyntax as AssignmentExpressionSyntax;
//string left = objectToCreateName + "." + GenerateExpression(assignmentExpressionSyntax.Left, semanticModel);
string expressionString = GenerateAssignmentExpression(assignmentExpressionSyntax, semanticModel);
initializations += objectToCreateName + "." + expressionString + ";\n";
}
else
{
//string left = objectToCreateName + "." + GenerateExpression(assignmentExpressionSyntax.Left, semanticModel);
string expressionString = GenerateExpression(expressionSyntax, semanticModel);
initializations += objectToCreateName + ".add(" + expressionString + ");\n";
}
}
string creationStatements = typeReference + " " + objectToCreateName + " = " + constructorCall + ";\n" +
initializations +
"return " + objectToCreateName + ";\n";
string constructAndInitialize = "((new by.besmart.cross.delegates.Func() {\n" +
"\t\tpublic " + typeReference + " invoke() {\n" +
creationStatements.AddTab(3) +
"}\n" +
"\t}).invoke())";
return(constructAndInitialize);
}
}
private string GenerateLambdaExpression(List <ParameterSyntax> parameters, INamedTypeSymbol typeSymbol, CSharpSyntaxNode body, SemanticModel semanticModel)
{
var delegateInfo = GetDelegateInfo(typeSymbol, semanticModel);
string delegateType = delegateInfo.JavaDelegateType;
TypeReference returnType = delegateInfo.ReturnType;
bool isFunc = delegateInfo.IsFunc;
var generatedParameters = new List <Var>();
for (int i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
var typeArgumentForParameter = typeSymbol.TypeArguments[i];
var typeReference = TypeReferenceGenerator.GenerateTypeReference(typeArgumentForParameter, semanticModel, isInGenericContext: true);
generatedParameters.Add(new Var
{
Name = parameter.Identifier.ValueText,
Type = typeReference
});
}
var statements = new List <string>();
if (body is BlockSyntax)
{
foreach (var statement in (body as BlockSyntax).Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
}
}
else if (body is InvocationExpressionSyntax)
{
string generatedInvocationExpression = GenerateInvocationExpression(body as InvocationExpressionSyntax,
semanticModel);
string statement = generatedInvocationExpression + ";";
if (!Equals(returnType, JavaTypeReferences.Void))
{
statement = "return " + statement;
}
statements.Add(statement);
}
else if (body is LiteralExpressionSyntax)
{
string statement = "return " + LiteralGenerator.Generate(body as LiteralExpressionSyntax, semanticModel) + ";";
statements.Add(statement);
}
else if (body is BinaryExpressionSyntax)
{
string statement = "return " + GenerateExpression(body as BinaryExpressionSyntax, semanticModel) + ";";
statements.Add(statement);
}
return(BuildLambdaExpression(delegateType, generatedParameters, returnType, statements, semanticModel));
}
private DelegateInfo GetDelegateInfo(INamedTypeSymbol typeSymbol, SemanticModel semanticModel)
{
string delegateType = "";
TypeReference returnType = null;
bool isFunc = typeSymbol.Name == "Func";
if (isFunc)
{
delegateType = "Func";
}
else
{
delegateType = "Action";
}
var typeParameters = new List <TypeReference>();
if (typeSymbol.IsGenericType)
{
for (int i = 0; i < typeSymbol.TypeArguments.Count(); i++)
{
var typeArgument = typeSymbol.TypeArguments[i];
var typeReference = TypeReferenceGenerator.GenerateTypeReference(typeArgument, semanticModel, isInGenericContext: true);
typeParameters.Add(typeReference);
if (!(isFunc && i == 0))
{
delegateType += "T";
}
}
delegateType = TypeReferenceBuilder.BuildTypeReference(new string[] { "by.besmart.cross.delegates", delegateType },
typeParameters);
}
else
{
delegateType = TypeReferenceBuilder.BuildTypeReference(new string[] { "by.besmart.cross.delegates", delegateType },
new List <TypeReference>());
}
returnType = isFunc ? typeParameters.Last() : JavaTypeReferences.Void;
return(new DelegateInfo
{
ReturnType = returnType,
JavaDelegateType = delegateType,
TypeParameters = typeParameters,
IsFunc = isFunc
});
}
private SourceCode GetFields(SemanticModel semanticModel, HashSet <string> typeReferences,
IEnumerable <FieldDeclarationSyntax> fieldsDeclarations)
{
var generatedFields = new SourceCode {
MainPart = ""
};
foreach (var fieldDeclaration in fieldsDeclarations)
{
var variables = fieldDeclaration.Declaration.Variables;
if (variables.Count != 1)
{
throw new NotImplementedException();
}
var variable = variables.First();
string identifier = variable.Identifier.ValueText;
var fieldType = fieldDeclaration.Declaration.Type;
var typeReference = TypeReferenceGenerator.GenerateTypeReference(fieldType, semanticModel);
if (!typeReference.IsPredefined)
{
typeReferences.Add(typeReference.Text);
}
bool isStatic = HasStaticModifier(fieldDeclaration.Modifiers.ToList());
string optionalStaticModifierText = isStatic ? "static " : "";
var fieldAccessModifier = GetAccessModifier(fieldDeclaration.Modifiers.ToList());
string generatedAccessModifier = fieldAccessModifier == AccessModifier.Public ? "public" : "private";
string initializerText = "";
if (variable.Initializer != null)
{
string initializerValueText = ExpressionGenerator
.GenerateExpression(variable.Initializer.Value, semanticModel);
initializerText += " = " + initializerValueText;
}
string generatedField =
generatedAccessModifier + " " + optionalStaticModifierText + typeReference.Text + " "
+ identifier + initializerText + ";\n";
generatedFields.MainPart += "\n" + generatedField;
}
return(generatedFields);
}
private string GenerateLocalDeclaration(LocalDeclarationStatementSyntax localDeclarationStatementSyntax, SemanticModel semanticModel)
{
var declaration = localDeclarationStatementSyntax.Declaration;
var declarationType = declaration.Type;
string generatedDeclarationType = TypeReferenceGenerator.GenerateTypeReference(declarationType, semanticModel).Text;
if (declaration.Variables.Count > 1)
{
throw new NotImplementedException();
}
var declarationVariable = declaration.Variables[0];
string variableName = declarationVariable.Identifier.ValueText;
string valueExpression = ExpressionGenerator.GenerateExpression(declarationVariable.Initializer.Value, semanticModel);
string generatedDeclaration = generatedDeclarationType + " " + variableName + " = " + valueExpression;
if (!variableName.StartsWith("___"))
{
generatedDeclaration = "final " + generatedDeclaration;
}
return(generatedDeclaration);
}
private string GenerateMemberAccessExpression(MemberAccessExpressionSyntax memberAccessExpressionSyntax, SemanticModel semanticModel)
{
string memberOwnerExpression = GenerateExpression(memberAccessExpressionSyntax.Expression, semanticModel);
var symbolInfo = ModelExtensions.GetSymbolInfo(semanticModel, memberAccessExpressionSyntax);
if (symbolInfo.Symbol.Kind == SymbolKind.Property)
{
string propertyName = memberAccessExpressionSyntax.Name.Identifier.ValueText;
var type = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, memberAccessExpressionSyntax).Type;
var ownerType = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, memberAccessExpressionSyntax.Expression).Type;
if (CustomPropertyAccessHelper.IsCustom(ownerType, propertyName))
{
return(CustomPropertyAccessHelper.Generate(ownerType, memberOwnerExpression, propertyName));
}
else
{
var typeReference = TypeReferenceGenerator.GenerateTypeReference(type, semanticModel);
string methodName = PropertyGenerator.GenerateGetterMethodName(typeReference, propertyName);
return(memberOwnerExpression + "." + GenerateMethodCallExpression(methodName, new List <string>()));
}
}
throw new NotImplementedException();
}
private string GenerateIdentifierExpression(IdentifierNameSyntax identifierNameSyntax, SemanticModel semanticModel)
{
var symbolInfo = ModelExtensions.GetSymbolInfo(semanticModel, identifierNameSyntax);
if (symbolInfo.Symbol.Kind == SymbolKind.Property)
{
string propertyName = identifierNameSyntax.Identifier.ValueText;
var type = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, identifierNameSyntax).Type;
var typeReference = TypeReferenceGenerator.GenerateTypeReference(type, semanticModel);
string methodName = PropertyGenerator.GenerateGetterMethodName(typeReference, propertyName);
return(GenerateMethodCallExpression(methodName, new List <string> {
}));
}
if (symbolInfo.Symbol.Kind == SymbolKind.Field)
{
return(identifierNameSyntax.Identifier.ValueText);
}
if (symbolInfo.Symbol.Kind == SymbolKind.Parameter)
{
return(identifierNameSyntax.Identifier.ValueText);
}
if (symbolInfo.Symbol.Kind == SymbolKind.Local)
{
return(identifierNameSyntax.Identifier.ValueText);
}
if (symbolInfo.Symbol.Kind == SymbolKind.NamedType)
{
return(TypeReferenceGenerator.GenerateTypeReference((ITypeSymbol)symbolInfo.Symbol, semanticModel).Text);
}
if (symbolInfo.Symbol.Kind == SymbolKind.Method)
{
var methodSymbol = symbolInfo.Symbol as IMethodSymbol;
var typeSymbol = ModelExtensions.GetTypeInfo(semanticModel, identifierNameSyntax).ConvertedType as INamedTypeSymbol;
var delegateInfo = GetDelegateInfo(typeSymbol, semanticModel);
var delegateTypeParameters = delegateInfo.TypeParameters;
var generatedParameters = new List <Var>();
if (delegateInfo.IsFunc)
{
delegateTypeParameters.RemoveAt(delegateTypeParameters.Count - 1);
}
for (int i = 0; i < delegateTypeParameters.Count; i++)
{
generatedParameters.Add(new Var
{
Name = "arg" + i,
Type = delegateTypeParameters[i]
});
}
string statement = delegateInfo.IsFunc ? "return " : "";
statement += methodSymbol.Name.ToLowerFirstChar() + "(";
for (int i = 0; i < generatedParameters.Count - 1; i++)
{
statement += generatedParameters[i].Name + ", ";
}
if (generatedParameters.Count > 0)
{
statement += generatedParameters[generatedParameters.Count - 1].Name;
}
statement += ");";
var statements = new List <string>
{
statement
};
return(BuildLambdaExpression(delegateInfo.JavaDelegateType, generatedParameters, delegateInfo.ReturnType, statements, semanticModel));
}
throw new NotImplementedException();
}
private string GenerateInvocationExpression(InvocationExpressionSyntax invocationExpressionSyntax, SemanticModel semanticModel)
{
var parameterExpressions = new List <string>();
foreach (var argument in invocationExpressionSyntax.ArgumentList.Arguments)
{
string parameterExpression = GenerateExpression(argument.Expression, semanticModel);
parameterExpressions.Add(parameterExpression);
}
var expression = invocationExpressionSyntax.Expression;
var symbolInfo = ModelExtensions.GetSymbolInfo(semanticModel, expression);
if (expression is IdentifierNameSyntax)
{
var identifierNameExpression = expression as IdentifierNameSyntax;
var namedTypeSymbol = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, expression).Type;
if (namedTypeSymbol != null && TypeReferenceGenerator.IsDelegateType(namedTypeSymbol))
{
return(identifierNameExpression.Identifier.ValueText + "." + GenerateMethodCallExpression("invoke", parameterExpressions));
}
string containingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(symbolInfo.Symbol.ContainingType);
string methodName = invocationExpressionSyntax.Expression.GetText()
.ToString().Trim();
return(GenerateMethodCallExpression(methodName, parameterExpressions));
}
if (expression is MemberAccessExpressionSyntax)
{
var memberAccessExpression = expression as MemberAccessExpressionSyntax;
string memberName = memberAccessExpression.Name.Identifier.ValueText;
string ownerExpression = GenerateExpression(memberAccessExpression.Expression, semanticModel);
if (symbolInfo.Symbol is IMethodSymbol && (symbolInfo.Symbol as IMethodSymbol).IsExtensionMethod)
{
var containingType = (symbolInfo.Symbol as IMethodSymbol).ContainingType;
string containingTypeReference = TypeReferenceGenerator.GenerateTypeReference(containingType, semanticModel).Text;
parameterExpressions.Insert(0, ownerExpression);
return(containingTypeReference + "." + GenerateMethodCallExpression(memberName, parameterExpressions));
}
if (symbolInfo.Symbol.Kind == SymbolKind.Method)
{
string containingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(symbolInfo.Symbol.ContainingType);
string methodName = memberName;
if (CustomMethodInvocationHelper.IsCustom(containingTypeFullName, methodName))
{
return(CustomMethodInvocationHelper.Generate(containingTypeFullName,
ownerExpression, methodName, parameterExpressions));
}
else
{
return(ownerExpression + "." + GenerateMethodCallExpression(methodName, parameterExpressions));
}
}
if (symbolInfo.Symbol.Kind == SymbolKind.Property && symbolInfo.Symbol is IPropertySymbol)
{
var propertyType = (symbolInfo.Symbol as IPropertySymbol).Type as INamedTypeSymbol;
if (TypeReferenceGenerator.IsDelegateType(propertyType))
{
string propertyName = memberAccessExpression.Name.Identifier.ValueText;
var type = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, memberAccessExpression).Type;
var typeReference = TypeReferenceGenerator.GenerateTypeReference(type, semanticModel);
string methodName = PropertyGenerator.GenerateGetterMethodName(typeReference, propertyName);
return(ownerExpression + "." + GenerateMethodCallExpression(methodName, new List <string>()) + "." +
GenerateMethodCallExpression("invoke", parameterExpressions));
}
throw new NotImplementedException();
}
throw new NotImplementedException();
}
throw new NotImplementedException();
}
private string GenerateCastExpression(CastExpressionSyntax castExpressionSyntax, SemanticModel semanticModel)
{
var typeReference = TypeReferenceGenerator.GenerateTypeReference(castExpressionSyntax.Type, semanticModel);
return("(" + typeReference.Text + ") " + GenerateExpression(castExpressionSyntax.Expression, semanticModel));
}
private SourceCode GetProperties(SemanticModel semanticModel, HashSet <string> typeReferences,
IEnumerable <PropertyDeclarationSyntax> propertyDeclarations, bool isFromInterface)
{
var generatedProperties = new SourceCode {
MainPart = ""
};
foreach (var propertyDeclaration in propertyDeclarations)
{
string identifier = propertyDeclaration.Identifier.ValueText;
var propertyType = propertyDeclaration.Type;
var typeReference = TypeReferenceGenerator.GenerateTypeReference(propertyType, semanticModel);
if (!typeReference.IsPredefined)
{
typeReferences.Add(typeReference.Text);
}
bool isStatic = HasStaticModifier(propertyDeclaration.Modifiers.ToList());
bool isVirtual = isFromInterface || HasVirtualModifier(propertyDeclaration.Modifiers.ToList());
var propertyAccessModifier = GetAccessModifier(propertyDeclaration.Modifiers.ToList());
var accessors = propertyDeclaration.AccessorList.Accessors;
var getAccessor = accessors.FirstOrDefault(syntax => syntax.Keyword.Text == "get");
var setAccessor = accessors.FirstOrDefault(syntax => syntax.Keyword.Text == "set");
if (propertyDeclaration.AccessorList.Accessors.Any(syntax => syntax.Body != null))
{
var complexPropertyDescription = new ComplexPropertyDescription
{
PropertyName = identifier,
PropertyType = typeReference,
GetAccessModifier = new Optional <AccessModifier>(),
SetAccessModifier = new Optional <AccessModifier>(),
IsStatic = isStatic,
IsVirtual = isVirtual
};
if (getAccessor != null)
{
var getAccessModifier = GetAccessModifier(getAccessor.Modifiers);
var getModifier = MaxRestrictionAccessModifier(propertyAccessModifier, getAccessModifier);
complexPropertyDescription.GetAccessModifier = getModifier;
if (getAccessor.Body != null)
{
var statements = new List <string>();
foreach (var statement in getAccessor.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
}
complexPropertyDescription.GetStatements = statements;
}
}
if (setAccessor != null)
{
var setAccessModifier = GetAccessModifier(setAccessor.Modifiers);
var setModifier = MaxRestrictionAccessModifier(propertyAccessModifier, setAccessModifier);
complexPropertyDescription.SetAccessModifier = setModifier;
if (setAccessor.Body != null)
{
var statements = new List <string>();
foreach (var statement in setAccessor.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
}
complexPropertyDescription.SetStatements = statements;
}
}
SourceCode generatedProperty = PropertyGenerator.GenerateComplexProperty(complexPropertyDescription, semanticModel);
generatedProperties.MainPart += "\n" + generatedProperty.MainPart;
}
else
{
var simplePropertyDescription = new SimplePropertyDescription
{
PropertyName = identifier,
PropertyType = typeReference,
GetAccessModifier = new Optional <AccessModifier>(),
SetAccessModifier = new Optional <AccessModifier>(),
IsStatic = isStatic,
IsVirtual = isVirtual,
IsFromInterface = isFromInterface
};
if (getAccessor != null)
{
var getAccessModifier = GetAccessModifier(getAccessor.Modifiers);
var getModifier = MaxRestrictionAccessModifier(propertyAccessModifier, getAccessModifier);
simplePropertyDescription.GetAccessModifier = getModifier;
}
if (setAccessor != null)
{
var setAccessModifier = GetAccessModifier(setAccessor.Modifiers);
var setModifier = MaxRestrictionAccessModifier(propertyAccessModifier, setAccessModifier);
simplePropertyDescription.SetAccessModifier = setModifier;
}
SourceCode generatedProperty = PropertyGenerator
.GenerateSimpleProperty(simplePropertyDescription, semanticModel, isFromInterface);
generatedProperties.MainPart += "\n" + generatedProperty.MainPart;
}
}
return(generatedProperties);
}
private SourceCode GetMethods(SemanticModel semanticModel, HashSet <string> typeReferences, IEnumerable <MethodDeclarationSyntax> methodDeclarations)
{
var generatedMethods = new SourceCode {
MainPart = ""
};
foreach (var methodDeclaration in methodDeclarations)
{
string identifier = methodDeclaration.Identifier.ValueText;
var returnType = methodDeclaration.ReturnType;
var returnTypeReference = TypeReferenceGenerator.GenerateTypeReference(returnType, semanticModel);
if (!returnTypeReference.IsPredefined)
{
typeReferences.Add(returnTypeReference.Text);
}
var typeParameters = new List <string>();
if (methodDeclaration.TypeParameterList != null)
{
foreach (var typeParameter in methodDeclaration.TypeParameterList.Parameters)
{
typeParameters.Add(typeParameter.Identifier.ValueText);
}
}
var parameters = new List <Var>();
foreach (var parameter in methodDeclaration.ParameterList.Parameters)
{
var typeReference = TypeReferenceGenerator.GenerateTypeReference(parameter.Type, semanticModel);
parameters.Add(new Var
{
Name = parameter.Identifier.ValueText,
Type = typeReference
});
}
var accessModifier = GetAccessModifier(methodDeclaration.Modifiers.ToList());
bool isStatic = HasStaticModifier(methodDeclaration.Modifiers.ToList());
Optional <List <string> > body;
if (methodDeclaration.Body == null)
{
body = new Optional <List <string> >();
}
else
{
var statements = new List <string>();
foreach (var statement in methodDeclaration.Body.Statements)
{
string generatedStatement = StatementGenerator.Generate(statement, semanticModel);
statements.Add(generatedStatement);
new Optional <List <string> >();
}
body = new Optional <List <string> >(statements);
}
bool isVirtual = !body.HasValue || HasVirtualModifier(methodDeclaration.Modifiers.ToList());
var generatedMethod = MethodGenerator.Generate(identifier,
returnTypeReference,
typeParameters,
accessModifier,
parameters,
body,
isStatic,
isVirtual,
semanticModel);
generatedMethods.MainPart += "\n" + generatedMethod.MainPart;
}
return(generatedMethods);
}
