private void GenerateOrdinaryClass(ClassDeclarationSyntax classDeclaration, SemanticModel semanticModel, string outputPath)
{
INamedTypeSymbol typeInfo = semanticModel.GetDeclaredSymbol(classDeclaration);
var fullyQualifiedNameParts = SyntaxTreeHelper.GetFullyQualifiedNameParts(typeInfo);
var genericTypeParameters = typeInfo.TypeParameters;
var typeReferences = new HashSet <string>();
var propertyDeclarations = classDeclaration.DescendantNodes().OfType <PropertyDeclarationSyntax>();
var generatedProperties = GetProperties(semanticModel, typeReferences, propertyDeclarations, false);
var fieldsDeclarations = classDeclaration.DescendantNodes().OfType <FieldDeclarationSyntax>();
var generatedFields = GetFields(semanticModel, typeReferences, fieldsDeclarations);
var constructorDeclarations = classDeclaration.DescendantNodes().OfType <ConstructorDeclarationSyntax>();
var generatedConstructors = GetConstructors(semanticModel, typeReferences, constructorDeclarations);
var methodDeclarations = classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>();
var generatedMethods = GetMethods(semanticModel, typeReferences, methodDeclarations);
var classSourceCode = TypeBuilder.BuildType(semanticModel,
fullyQualifiedNameParts, genericTypeParameters,
typeInfo.BaseType,
typeInfo.AllInterfaces,
generatedConstructors,
generatedFields,
generatedProperties,
generatedMethods);
WriteToOutputIfPathPresent(outputPath, fullyQualifiedNameParts, classSourceCode.MainPart);
}
private string GenerateExceptionCreationExpression(ObjectCreationExpressionSyntax exceptionCreationExpressionSyntax, SemanticModel semanticModel)
{
var exceptionType = (INamedTypeSymbol)ModelExtensions.GetTypeInfo(semanticModel, exceptionCreationExpressionSyntax).Type;
string exceptionTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(exceptionType);
string generatedExceptionName = "";
if (exceptionTypeFullName == "System.ArgumentNullException")
{
generatedExceptionName = "IllegalArgumentException";
}
else if (exceptionTypeFullName == "System.ArgumentException")
{
generatedExceptionName = "IllegalArgumentException";
}
else if (exceptionTypeFullName == "System.NullReferenceException")
{
generatedExceptionName = "NullPointerException";
}
else if (exceptionTypeFullName == "System.InvalidOperationException")
{
generatedExceptionName = "IllegalStateException";
}
else
{
throw new NotSupportedException();
}
string argumentList = ArgumentListGenerator.Generate(exceptionCreationExpressionSyntax.ArgumentList, semanticModel);
return("new " + generatedExceptionName + argumentList);
}
private void Generate(EnumDeclarationSyntax enumDeclaration, SemanticModel semanticModel, string outputPath)
{
INamedTypeSymbol typeInfo = semanticModel.GetDeclaredSymbol(enumDeclaration);
var fullyQualifiedNameParts = SyntaxTreeHelper.GetFullyQualifiedNameParts(typeInfo);
var sourceCode = TypeBuilder.BuildEnum(semanticModel, fullyQualifiedNameParts, enumDeclaration.Members);
WriteToOutputIfPathPresent(outputPath, fullyQualifiedNameParts, sourceCode.MainPart);
}
public void NameOfConstEvaluatorTest(string textExpression, string expectedValue)
{
var walker = new ConstantExpressionSyntaxEvaluator <string>();
var exp = SyntaxTreeHelper.GetExpressionSyntax($"nameof({textExpression})");
var value = walker.Visit(exp);
Assert.Equal(expectedValue, value);
}
public static bool IsCustom(INamedTypeSymbol accessingType)
{
string accessingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(accessingType);
if (accessingTypeFullName == "System.String")
{
return(true);
}
return(false);
}
public void SimpleStringConstEvaluatorTest()
{
var textValue = "MyValue";
var walker = new ConstantExpressionSyntaxEvaluator <string>();
var exp = SyntaxTreeHelper.GetExpressionSyntax($@"""{textValue}""");
var value = walker.Visit(exp);
Assert.Equal(textValue, value);
}
public void PropertyTypeWriterTest(string patternImplFieldType, string expectedGeneratedFieldName)
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1));
var implPatternFieldNode = SyntaxTreeHelper.GetFieldSyntax(patternImplFieldType, PatternFieldName);
var generatedField = NodeWriterHelper.WriteAndAssertSingleMemberOfType <FieldDeclarationSyntax>(pw, implPatternFieldNode);
Assert.Equal(expectedGeneratedFieldName, generatedField.Declaration.Type.ToString());
}
public static string Generate(INamedTypeSymbol containingType,
string ownerExpression,
string propertyName)
{
string accessingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(containingType);
return(Generate(accessingTypeFullName,
ownerExpression,
propertyName));
}
public void SimpleFieldWriterTest(string patternFieldName, string expectedImplPropName)
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1));
var implPatternPropNode = SyntaxTreeHelper.GetFieldSyntax(PatternPropType, patternFieldName);
var fieldProperty = NodeWriterHelper.WriteAndAssertSingleMemberOfType <FieldDeclarationSyntax>(pw, implPatternPropNode);
Assert.Equal(expectedImplPropName, fieldProperty.Declaration.Variables.Single().Identifier.Text);
Assert.Equal(DeclPropType1, fieldProperty.Declaration.Type.ToString());
}
public void SimplePropertyWriterTest(string type, string name, string genType, string genName)
{
var srw = SetupStringReplaceWriter("PatternClassName", "NewClassString");
var implPatternPropNode = SyntaxTreeHelper.GetPropertyImplSyntax(type, name);
var generatedProperty = NodeWriterHelper.WriteAndAssertSingleMemberOfType <PropertyDeclarationSyntax>(srw, implPatternPropNode);
Assert.Equal(genName, generatedProperty.Identifier.Text);
Assert.Equal(genType, generatedProperty.Type.ToString());
}
public void SimplePropertyWriterTest()
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1));
var implPatternPropNode = SyntaxTreeHelper.GetPropertyImplSyntax(PatternPropType, PatternPropName);
var generatedProperty = NodeWriterHelper.WriteAndAssertSingleMemberOfType <PropertyDeclarationSyntax>(pw, implPatternPropNode);
Assert.Equal(DeclPropName1, generatedProperty.Identifier.Text);
Assert.Equal(DeclPropType1, generatedProperty.Type.ToString());
}
public static void ProcessClass(ClassDeclarationSyntax classDeclaration, NamespaceDeclarationSyntax namespaceDeclaration)
{
var nativeImplementationAttribute =
SyntaxTreeHelper.GetNativeImplementationAttribute(classDeclaration);
if (nativeImplementationAttribute.HasValue)
{
ProcessNativeImplementationClass(classDeclaration, namespaceDeclaration);
return;
}
ProcessOrdinaryClass(classDeclaration, namespaceDeclaration);
}
public void MultiPropertyWriterTest()
{
var srw = SetupStringReplaceWriter("PatternClassName", new[] { "NewClassString1", "NewClassString2" });
var implPatternPropNode = SyntaxTreeHelper.GetPropertyImplSyntax("object", "PatternClassName");
var generatedProperties = NodeWriterHelper.WriteAndAssertMultiMemberOfType <PropertyDeclarationSyntax>(srw, implPatternPropNode);
Assert.Equal(2, generatedProperties.Count);
Assert.Equal("NewClassString1", generatedProperties[0].Identifier.Text);
Assert.Equal("NewClassString2", generatedProperties[1].Identifier.Text);
}
public static string Generate(INamedTypeSymbol containingType,
string ownerExpression,
string methodName,
List <string> parameterExpressions)
{
string accessingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(containingType);
return(Generate(accessingTypeFullName,
ownerExpression,
methodName,
parameterExpressions));
}
public void PropertyWithAccessorsWriterTest(string patternFieldName, string implPropName)
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1));
var implPatternPropNode = SyntaxTreeHelper.GetPropertyImplSyntax(PatternPropType, PatternPropName, patternFieldName);
var generatedProperty = NodeWriterHelper.WriteAndAssertSingleMemberOfType <PropertyDeclarationSyntax>(pw, implPatternPropNode);
Assert.Equal(DeclPropName1, generatedProperty.Identifier.Text);
Assert.Equal(DeclPropType1, generatedProperty.Type.ToString());
Assert.Contains(implPropName, generatedProperty.AccessorList.ToFullString(), StringComparison.InvariantCulture);
Assert.DoesNotContain(patternFieldName, generatedProperty.AccessorList.ToFullString(), StringComparison.InvariantCulture);
}
public static bool IsCustom(INamedTypeSymbol leftOperandType, string operatorString)
{
string accessingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(leftOperandType);
if (accessingTypeFullName == "System.String")
{
if (operatorString == "==")
{
return(true);
}
}
return(false);
}
public void UnknownDeclarationUseLoadingTest()
{
var walker = SetupDeclarationUseWalker();
var node = SyntaxTreeHelper.GetTypeSyntax("Unknown");
var declarationUse = walker.Visit(node);
Assert.NotNull(declarationUse);
Assert.IsType <UnknownDeclarationUse>(declarationUse);
Assert.NotNull(declarationUse.Declaration);
Assert.IsType <UnknownDeclaration>(declarationUse.Declaration);
}
public void SimpleVariableStatementWriterTest(string patternVariableName, string implPropName)
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1));
var implPatternVariableNode = SyntaxTreeHelper.GetLocalDeclarationStatementSyntax(
PatternPropType, $"{patternVariableName}Version", $"this.{patternVariableName}.Version");
var variableProperty = NodeWriterHelper.WriteAndAssertSingleMemberOfType <FieldDeclarationSyntax>(
pw, implPatternVariableNode);
Assert.Equal($"{implPropName}Version", variableProperty.Declaration.Variables.Single().Identifier.Text);
Assert.Equal($"this.{implPropName}.Version", variableProperty.Declaration.Variables.Single().Initializer.Value.ToString());
}
private void Generate(ClassDeclarationSyntax classDeclaration, SemanticModel semanticModel, string outputPath)
{
var nativeImplementationAttribute =
SyntaxTreeHelper.GetNativeImplementationAttribute(classDeclaration);
if (!nativeImplementationAttribute.HasValue)
{
GenerateOrdinaryClass(classDeclaration, semanticModel, outputPath);
}
else
{
ProcessNativeImplementationClass(classDeclaration, semanticModel, outputPath);
}
}
public static string Generate(INamedTypeSymbol accessingType,
string accessingExpression,
string generatedArgument,
ElementAccessExpressionSyntax elementAccessExpressionSyntax,
SemanticModel semanticModel)
{
string accessingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(accessingType);
if (accessingTypeFullName == "System.String")
{
return(accessingExpression + ".charAt(" + generatedArgument + ")");
}
throw new ArgumentException();
}
private bool IsExceptionType(INamedTypeSymbol typeSymbol)
{
string baseExceptionType = "System.Exception";
while (typeSymbol != null)
{
string typeFullName = SyntaxTreeHelper.GetFullyQualifiedName(typeSymbol);
if (typeFullName == baseExceptionType)
{
return(true);
}
typeSymbol = typeSymbol.BaseType;
}
return(false);
}
public void SimpleMethodWriterTest(
string patternMethodName,
string patternMethodArgumentName,
string expectedImplMethodName,
string expectedArgName)
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1));
var implPatternMethodNode = SyntaxTreeHelper.GetMethodSyntax(PatternPropType, patternMethodName, patternMethodArgumentName, ", string otherArg");
var methodProperty = NodeWriterHelper.WriteAndAssertSingleMemberOfType <MethodDeclarationSyntax>(pw, implPatternMethodNode);
Assert.Equal(expectedImplMethodName, methodProperty.Identifier.Text);
Assert.Equal(expectedArgName, methodProperty.ParameterList.Parameters.First().Identifier.Text);
Assert.Equal(DeclPropType1, methodProperty.ReturnType.ToString());
}
public void ExpressionBodyPropertyWriterTest()
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1));
var implPatternPropNode = SyntaxTreeHelper.GetExpressionBodyPropertyImplSyntax(
PatternPropType,
PatternPropName,
$"this.{PatternFieldName}");
var generatedProperty = NodeWriterHelper
.WriteAndAssertSingleMemberOfType <PropertyDeclarationSyntax>(pw, implPatternPropNode);
Assert.Equal(DeclPropName1, generatedProperty.Identifier.Text);
Assert.Equal(DeclPropType1, generatedProperty.Type.ToString());
Assert.NotNull(generatedProperty.ExpressionBody);
Assert.Equal($"=> this.{DeclFieldName1}", generatedProperty.ExpressionBody.ToString());
}
public static string Generate(INamedTypeSymbol leftOperandType,
string leftExpression,
string operatorString,
string rightExpression,
SemanticModel semanticModel)
{
string accessingTypeFullName = SyntaxTreeHelper.GetFullyQualifiedName(leftOperandType);
if (accessingTypeFullName == "System.String")
{
if (operatorString == "==")
{
return("by.besmart.cross.SystemStringUtils.equals(" + leftExpression + ", " + rightExpression + ")");
}
}
throw new ArgumentException();
}
public void GenericParameterDeclarationUseLoadingTest()
{
var declarationUseStatement = "TName";
IGenericParameterDeclaration genericParameterDeclaration = null;
var walker = SetupDeclarationUseWalker(ctx =>
{
genericParameterDeclaration = SetupGenericParameterDeclaration(ctx, declarationUseStatement);
});
var node = SyntaxTreeHelper.GetTypeSyntax(declarationUseStatement);
var declarationUse = walker.Visit(node);
Assert.NotNull(declarationUse);
Assert.IsType <GenericParameterDeclarationUse>(declarationUse);
Assert.Same(genericParameterDeclaration, declarationUse.Declaration);
}
public void MultiPropertyDeclarationWriterTest()
{
var pw = SetupPropertyWriter(PatternPropType, PatternPropName, (DeclPropType1, DeclPropName1), (DeclPropType2, DeclPropName2));
var implPatternFieldNode = SyntaxTreeHelper.GetFieldSyntax(PatternPropType, PatternFieldName);
var generatedFields = NodeWriterHelper.WriteAndAssertMultiMemberOfType <FieldDeclarationSyntax>(pw, implPatternFieldNode);
Assert.Equal(2, generatedFields.Count);
Assert.Equal(DeclPropType1, generatedFields[0].Declaration.Type.ToString());
var v1 = Assert.Single(generatedFields[0].Declaration.Variables);
Assert.Equal(DeclFieldName1, v1.Identifier.ValueText);
Assert.Equal(DeclPropType2, generatedFields[1].Declaration.Type.ToString());
var v2 = Assert.Single(generatedFields[1].Declaration.Variables);
Assert.Equal(DeclFieldName2, v2.Identifier.ValueText);
}
private void Generate(InterfaceDeclarationSyntax interfaceDeclaration, SemanticModel semanticModel, string outputPath)
{
INamedTypeSymbol typeInfo = semanticModel.GetDeclaredSymbol(interfaceDeclaration);
var fullyQualifiedNameParts = SyntaxTreeHelper.GetFullyQualifiedNameParts(typeInfo);
var genericTypeParameters = typeInfo.TypeParameters;
var typeReferences = new HashSet <string>();
var propertyDeclarations = interfaceDeclaration.DescendantNodes().OfType <PropertyDeclarationSyntax>();
var generatedProperties = GetProperties(semanticModel, typeReferences, propertyDeclarations, true);
var methodDeclarations = interfaceDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>();
var generatedMethods = GetMethods(semanticModel, typeReferences, methodDeclarations);
var interfaceSourceCode = TypeBuilder.BuildInterface(semanticModel,
fullyQualifiedNameParts, genericTypeParameters,
generatedProperties,
generatedMethods);
WriteToOutputIfPathPresent(outputPath, fullyQualifiedNameParts, interfaceSourceCode.MainPart);
}
public void GenericTypeParameterFieldPropertyWriterTest()
{
var itfType = "IList<IPatternType>";
var declType = "IList<IDeclType>";
var patternFieldType = "AnyImplType<IPatternType>";
var expectedFieldType = "AnyImplType<IDeclType>";
var pw = SetupPropertyWriter(
itfType,
PatternPropName,
TypeParamExtract,
(declType, DeclPropName1));
var implPatternFieldNode = SyntaxTreeHelper.GetFieldSyntax(patternFieldType, PatternFieldName);
var generatedFields = NodeWriterHelper.WriteAndAssertMultiMemberOfType <FieldDeclarationSyntax>(pw, implPatternFieldNode);
var field = Assert.Single(generatedFields);
Assert.Equal(expectedFieldType, field.Declaration.Type.ToString());
}
public void GenericDeclarationUseLoadingTest(string declarationName, string genericParametersText, int genericParams)
{
var declarationMock = new Mock <IClassDeclaration>();
var walker = SetupDeclarationUseWalker(resolverSetup: resolver =>
{
if (genericParams == 0)
{
resolver
.Setup(r => r.Resolve(declarationName, It.IsAny <IDeclaration <SyntaxNode> >()))
.Returns(declarationMock.Object);
resolver
.Setup(r => r.Resolve(declarationName, Array.Empty <IDeclarationUse <SyntaxNode> >(), It.IsAny <IDeclaration <SyntaxNode> >()))
.Returns(declarationMock.Object);
}
else
{
resolver
.Setup(r => r.Resolve(declarationName, It.IsAny <IReadOnlyList <IDeclarationUse <SyntaxNode> > >(), It.IsAny <IDeclaration <SyntaxNode> >()))
.Returns(declarationMock.Object);
}
});
var node = SyntaxTreeHelper.GetTypeSyntax($"{declarationName}{genericParametersText}");
var declarationUse = walker.Visit(node);
Assert.NotNull(declarationUse);
Assert.Same(declarationMock.Object, declarationUse.Declaration);
var genericDeclarationUse = Assert.IsType <GenericDeclarationUse>(declarationUse);
Assert.NotNull(genericDeclarationUse.GenericParameters);
Assert.Equal(genericParams, genericDeclarationUse.GenericParameters.Count);
foreach (var genericParameter in genericDeclarationUse.GenericParameters)
{
Assert.IsType <PredefinedDeclarationUse>(genericParameter);
}
}
public TypeReference BuildDelegateReference(INamedTypeSymbol namedTypeSymbol, SemanticModel semanticModel)
{
var fullyQualifiedPropertyTypeNameParts = SyntaxTreeHelper.GetFullyQualifiedNameParts(namedTypeSymbol);
string name = namedTypeSymbol.Name;
bool isAction = name == "Action";
bool isFunc = name == "Func";
if (namedTypeSymbol.IsGenericType)
{
var typeParameters = new List <TypeReference>();
var args = namedTypeSymbol.TypeArguments.ToList();
for (int i = 0; i < args.Count; i++)
{
var typeArgument = args[i];
var typeReference = GenerateTypeReference(typeArgument, semanticModel, isInGenericContext: true);
typeParameters.Add(typeReference);
if (!(isFunc && i == 0))
{
name += "T";
}
}
string typeReferenceText = TypeReferenceBuilder
.BuildTypeReference(new[] { "by.besmart.cross.delegates", name }, typeParameters);
return(new TypeReference
{
Text = typeReferenceText,
IsReferenceType = namedTypeSymbol.IsReferenceType,
IsGeneric = true
});
}
string typeReferenceTextNonGeneric = TypeReferenceBuilder
.BuildTypeReference(new[] { "by.besmart.cross.delegates", name }, new List <TypeReference>());
return(new TypeReference
{
Text = typeReferenceTextNonGeneric,
IsReferenceType = namedTypeSymbol.IsReferenceType
});
}